public virtual void TestOldRenameWithQuota() { DistributedFileSystem fs = cluster.GetFileSystem(); Path src1 = GetTestRootPath(fc, "test/testOldRenameWithQuota/srcdir/src1"); Path src2 = GetTestRootPath(fc, "test/testOldRenameWithQuota/srcdir/src2"); Path dst1 = GetTestRootPath(fc, "test/testOldRenameWithQuota/dstdir/dst1"); Path dst2 = GetTestRootPath(fc, "test/testOldRenameWithQuota/dstdir/dst2"); CreateFile(src1); CreateFile(src2); fs.SetQuota(src1.GetParent(), HdfsConstants.QuotaDontSet, HdfsConstants.QuotaDontSet ); fc.Mkdir(dst1.GetParent(), FileContext.DefaultPerm, true); fs.SetQuota(dst1.GetParent(), 2, HdfsConstants.QuotaDontSet); /* * Test1: src does not exceed quota and dst has no quota check and hence * accommodates rename */ OldRename(src1, dst1, true, false); /* * Test2: src does not exceed quota and dst has *no* quota to accommodate * rename. */ // dstDir quota = 1 and dst1 already uses it OldRename(src2, dst2, false, true); /* * Test3: src exceeds quota and dst has *no* quota to accommodate rename */ // src1 has no quota to accommodate new rename node fs.SetQuota(src1.GetParent(), 1, HdfsConstants.QuotaDontSet); OldRename(dst1, src1, false, true); }
public virtual void TestRenameWithQuota() { DistributedFileSystem fs = cluster.GetFileSystem(); Path src1 = GetTestRootPath(fc, "test/testRenameWithQuota/srcdir/src1"); Path src2 = GetTestRootPath(fc, "test/testRenameWithQuota/srcdir/src2"); Path dst1 = GetTestRootPath(fc, "test/testRenameWithQuota/dstdir/dst1"); Path dst2 = GetTestRootPath(fc, "test/testRenameWithQuota/dstdir/dst2"); CreateFile(src1); CreateFile(src2); fs.SetQuota(src1.GetParent(), HdfsConstants.QuotaDontSet, HdfsConstants.QuotaDontSet ); fc.Mkdir(dst1.GetParent(), FileContext.DefaultPerm, true); fs.SetQuota(dst1.GetParent(), 2, HdfsConstants.QuotaDontSet); /* * Test1: src does not exceed quota and dst has no quota check and hence * accommodates rename */ // rename uses dstdir quota=1 Rename(src1, dst1, false, true, false, Options.Rename.None); // rename reuses dstdir quota=1 Rename(src2, dst1, true, true, false, Options.Rename.Overwrite); /* * Test2: src does not exceed quota and dst has *no* quota to accommodate * rename. */ // dstDir quota = 1 and dst1 already uses it CreateFile(src2); Rename(src2, dst2, false, false, true, Options.Rename.None); /* * Test3: src exceeds quota and dst has *no* quota to accommodate rename * rename to a destination that does not exist */ // src1 has no quota to accommodate new rename node fs.SetQuota(src1.GetParent(), 1, HdfsConstants.QuotaDontSet); Rename(dst1, src1, false, false, true, Options.Rename.None); /* * Test4: src exceeds quota and dst has *no* quota to accommodate rename * rename to a destination that exists and quota freed by deletion of dst * is same as quota needed by src. */ // src1 has no quota to accommodate new rename node fs.SetQuota(src1.GetParent(), 100, HdfsConstants.QuotaDontSet); CreateFile(src1); fs.SetQuota(src1.GetParent(), 1, HdfsConstants.QuotaDontSet); Rename(dst1, src1, true, true, false, Options.Rename.Overwrite); }
public virtual void TestCreateFileInNonExistingDirectory() { string fileName = "testDir/testFile"; Path testPath = QualifiedPath(fileName, fc2); // Ensure file does not exist NUnit.Framework.Assert.IsFalse(FileContextTestHelper.Exists(fc2, testPath)); // Create a file on fc2's file system using fc1 FileContextTestHelper.CreateFile(fc1, testPath); // Ensure using fc2 that file is created Assert.True(FileContextTestHelper.IsDir(fc2, testPath.GetParent ())); Assert.Equal("testDir", testPath.GetParent().GetName()); Assert.True(FileContextTestHelper.Exists(fc2, testPath)); }
/// <exception cref="System.IO.IOException"/> public override FSDataOutputStream CreateInternal(Path f, EnumSet <CreateFlag> flag , FsPermission absolutePermission, int bufferSize, short replication, long blockSize , Progressable progress, Options.ChecksumOpt checksumOpt, bool createParent) { // call to primitiveCreate CheckPath(f); // Default impl assumes that permissions do not matter // calling the regular create is good enough. // FSs that implement permissions should override this. if (!createParent) { // parent must exist. // since this.create makes parent dirs automatically // we must throw exception if parent does not exist. FileStatus stat = GetFileStatus(f.GetParent()); if (stat == null) { throw new FileNotFoundException("Missing parent:" + f); } if (!stat.IsDirectory()) { throw new ParentNotDirectoryException("parent is not a dir:" + f); } } // parent does exist - go ahead with create of file. return(fsImpl.PrimitiveCreate(f, absolutePermission, flag, bufferSize, replication , blockSize, progress, checksumOpt)); }
/// <exception cref="System.IO.IOException"/> private bool MkdirsWithOptionalPermission(Path f, FsPermission permission) { if (f == null) { throw new ArgumentException("mkdirs path arg is null"); } Path parent = f.GetParent(); FilePath p2f = PathToFile(f); FilePath parent2f = null; if (parent != null) { parent2f = PathToFile(parent); if (parent2f != null && parent2f.Exists() && !parent2f.IsDirectory()) { throw new ParentNotDirectoryException("Parent path is not a directory: " + parent ); } } if (p2f.Exists() && !p2f.IsDirectory()) { throw new FileNotFoundException("Destination exists" + " and is not a directory: " + p2f.GetCanonicalPath()); } return((parent == null || parent2f.Exists() || Mkdirs(parent)) && (MkOneDirWithMode (f, p2f, permission) || p2f.IsDirectory())); }
/// <exception cref="System.IO.IOException"/> public static void TrashNonDefaultFS(Configuration conf) { conf.SetLong(FsTrashIntervalKey, 10); { // 10 minute // attempt non-default FileSystem trash FileSystem lfs = FileSystem.GetLocal(conf); Path p = TestDir; Path f = new Path(p, "foo/bar"); if (lfs.Exists(p)) { lfs.Delete(p, true); } try { FileSystemTestHelper.WriteFile(lfs, f, 10); FileSystem.CloseAll(); FileSystem localFs = FileSystem.Get(URI.Create("file:///"), conf); Trash lTrash = new Trash(localFs, conf); lTrash.MoveToTrash(f.GetParent()); CheckTrash(localFs, lTrash.GetCurrentTrashDir(), f); } finally { if (lfs.Exists(p)) { lfs.Delete(p, true); } } } }
/// <summary>Two buffer dirs.</summary> /// <remarks> /// Two buffer dirs. The first dir does not exist & is on a read-only disk; /// The second dir exists & is RW /// getLocalPathForWrite with checkAccess set to false should create a parent /// directory. With checkAccess true, the directory should not be created. /// </remarks> /// <exception cref="System.Exception"/> /// <exception cref="System.IO.IOException"/> public virtual void TestLocalPathForWriteDirCreation() { string dir0 = BuildBufferDir(Root, 0); string dir1 = BuildBufferDir(Root, 1); try { conf.Set(Context, dir0 + "," + dir1); Assert.True(localFs.Mkdirs(new Path(dir1))); BufferRoot.SetReadOnly(); Path p1 = dirAllocator.GetLocalPathForWrite("p1/x", SmallFileSize, conf); Assert.True(localFs.GetFileStatus(p1.GetParent()).IsDirectory() ); Path p2 = dirAllocator.GetLocalPathForWrite("p2/x", SmallFileSize, conf, false); try { localFs.GetFileStatus(p2.GetParent()); } catch (Exception e) { Assert.Equal(e.GetType(), typeof(FileNotFoundException)); } } finally { Shell.ExecCommand(Shell.GetSetPermissionCommand("u+w", false, BufferDirRoot)); RmBufferDirs(); } }
/// <exception cref="System.IO.IOException"/> public override void CreateSymlink(Path target, Path link, bool createParent) { if (!FileSystem.AreSymlinksEnabled()) { throw new NotSupportedException("Symlinks not supported"); } string targetScheme = target.ToUri().GetScheme(); if (targetScheme != null && !"file".Equals(targetScheme)) { throw new IOException("Unable to create symlink to non-local file " + "system: " + target.ToString()); } if (createParent) { Mkdirs(link.GetParent()); } // NB: Use createSymbolicLink in java.nio.file.Path once available int result = FileUtil.SymLink(target.ToString(), MakeAbsolute(link).ToString()); if (result != 0) { throw new IOException("Error " + result + " creating symlink " + link + " to " + target); } }
public virtual void TestCreateDirectory() { Path path = QualifiedPath("test/hadoop", fc2); Path falsePath = QualifiedPath("path/doesnot.exist", fc2); Path subDirPath = QualifiedPath("dir0", fc2); // Ensure that testPath does not exist in fc1 NUnit.Framework.Assert.IsFalse(FileContextTestHelper.Exists(fc1, path)); NUnit.Framework.Assert.IsFalse(FileContextTestHelper.IsFile(fc1, path)); NUnit.Framework.Assert.IsFalse(FileContextTestHelper.IsDir(fc1, path)); // Create a directory on fc2's file system using fc1 fc1.Mkdir(path, FsPermission.GetDefault(), true); // Ensure fc2 has directory Assert.True(FileContextTestHelper.IsDir(fc2, path)); Assert.True(FileContextTestHelper.Exists(fc2, path)); NUnit.Framework.Assert.IsFalse(FileContextTestHelper.IsFile(fc2, path)); // Test to create same dir twice, (HDFS mkdir is similar to mkdir -p ) fc1.Mkdir(subDirPath, FsPermission.GetDefault(), true); // This should not throw exception fc1.Mkdir(subDirPath, FsPermission.GetDefault(), true); // Create Sub Dirs fc1.Mkdir(subDirPath, FsPermission.GetDefault(), true); // Check parent dir Path parentDir = path.GetParent(); Assert.True(FileContextTestHelper.Exists(fc2, parentDir)); NUnit.Framework.Assert.IsFalse(FileContextTestHelper.IsFile(fc2, parentDir)); // Check parent parent dir Path grandparentDir = parentDir.GetParent(); Assert.True(FileContextTestHelper.Exists(fc2, grandparentDir)); NUnit.Framework.Assert.IsFalse(FileContextTestHelper.IsFile(fc2, grandparentDir)); // Negative test cases NUnit.Framework.Assert.IsFalse(FileContextTestHelper.Exists(fc2, falsePath)); NUnit.Framework.Assert.IsFalse(FileContextTestHelper.IsDir(fc2, falsePath)); // TestCase - Create multiple directories string[] dirNames = new string[] { "createTest/testDir", "createTest/test Dir", "deleteTest/test*Dir" , "deleteTest/test#Dir", "deleteTest/test1234", "deleteTest/test_DIr", "deleteTest/1234Test" , "deleteTest/test)Dir", "deleteTest/()&^%$#@!~_+}{><?", " ", "^ " }; foreach (string f in dirNames) { if (!IsTestableFileNameOnPlatform(f)) { continue; } // Create a file on fc2's file system using fc1 Path testPath = QualifiedPath(f, fc2); // Ensure file does not exist NUnit.Framework.Assert.IsFalse(FileContextTestHelper.Exists(fc2, testPath)); // Now create directory fc1.Mkdir(testPath, FsPermission.GetDefault(), true); // Ensure fc2 has the created directory Assert.True(FileContextTestHelper.Exists(fc2, testPath)); Assert.True(FileContextTestHelper.IsDir(fc2, testPath)); } }
/// <summary> /// Return a fully-qualified version of the given symlink target if it /// has no scheme and authority. /// </summary> /// <remarks> /// Return a fully-qualified version of the given symlink target if it /// has no scheme and authority. Partially and fully-qualified paths /// are returned unmodified. /// </remarks> /// <param name="pathURI">URI of the filesystem of pathWithLink</param> /// <param name="pathWithLink">Path that contains the symlink</param> /// <param name="target">The symlink's absolute target</param> /// <returns>Fully qualified version of the target.</returns> public static Path QualifySymlinkTarget(URI pathURI, Path pathWithLink, Path target ) { // NB: makeQualified uses the target's scheme and authority, if // specified, and the scheme and authority of pathURI, if not. URI targetUri = target.ToUri(); string scheme = targetUri.GetScheme(); string auth = targetUri.GetAuthority(); return((scheme == null && auth == null) ? target.MakeQualified(pathURI, pathWithLink .GetParent()) : target); }
/// <summary>Creates a file on the local FS.</summary> /// <remarks> /// Creates a file on the local FS. Pass size as /// <see cref="LocalDirAllocator.SIZE_UNKNOWN"/> /// if not known apriori. We /// round-robin over the set of disks (via the configured dirs) and return /// a file on the first path which has enough space. The file is guaranteed /// to go away when the JVM exits. /// </remarks> /// <exception cref="System.IO.IOException"/> public virtual FilePath CreateTmpFileForWrite(string pathStr, long size, Configuration conf) { // find an appropriate directory Path path = GetLocalPathForWrite(pathStr, size, conf, true); FilePath dir = new FilePath(path.GetParent().ToUri().GetPath()); string prefix = path.GetName(); // create a temp file on this directory FilePath result = FilePath.CreateTempFile(prefix, null, dir); result.DeleteOnExit(); return(result); }
public override void Initialize(Configuration conf, FileSystem fs, Path home) { this.fs = fs; this.trash = new Path(home, Trash); this.homesParent = home.GetParent(); this.current = new Path(trash, Current); this.deletionInterval = (long)(conf.GetFloat(CommonConfigurationKeysPublic.FsTrashIntervalKey , CommonConfigurationKeysPublic.FsTrashIntervalDefault) * MsecsPerMinute); this.emptierInterval = (long)(conf.GetFloat(CommonConfigurationKeysPublic.FsTrashCheckpointIntervalKey , CommonConfigurationKeysPublic.FsTrashCheckpointIntervalDefault) * MsecsPerMinute ); Log.Info("Namenode trash configuration: Deletion interval = " + (this.deletionInterval / MsecsPerMinute) + " minutes, Emptier interval = " + (this.emptierInterval / MsecsPerMinute ) + " minutes."); }
public virtual void TestEditsLogRename() { DistributedFileSystem fs = cluster.GetFileSystem(); Path src1 = GetTestRootPath(fc, "testEditsLogRename/srcdir/src1"); Path dst1 = GetTestRootPath(fc, "testEditsLogRename/dstdir/dst1"); CreateFile(src1); fs.Mkdirs(dst1.GetParent()); CreateFile(dst1); // Set quota so that dst1 parent cannot allow under it new files/directories fs.SetQuota(dst1.GetParent(), 2, HdfsConstants.QuotaDontSet); // Free up quota for a subsequent rename fs.Delete(dst1, true); Rename(src1, dst1, true, true, false, Options.Rename.Overwrite); // Restart the cluster and ensure the above operations can be // loaded from the edits log RestartCluster(); fs = cluster.GetFileSystem(); src1 = GetTestRootPath(fc, "testEditsLogRename/srcdir/src1"); dst1 = GetTestRootPath(fc, "testEditsLogRename/dstdir/dst1"); NUnit.Framework.Assert.IsFalse(fs.Exists(src1)); // ensure src1 is already renamed NUnit.Framework.Assert.IsTrue(fs.Exists(dst1)); }
/// <exception cref="System.IO.IOException"/> protected internal virtual string GenerateAndLogErrorListing(Org.Apache.Hadoop.FS.Path src, Org.Apache.Hadoop.FS.Path dst) { FileSystem fs = GetFileSystem(); GetLog().Error("src dir " + ContractTestUtils.Ls(fs, src.GetParent())); string destDirLS = ContractTestUtils.Ls(fs, dst.GetParent()); if (fs.IsDirectory(dst)) { //include the dir into the listing destDirLS = destDirLS + "\n" + ContractTestUtils.Ls(fs, dst); } return(destDirLS); }
/// <exception cref="System.IO.IOException"/> private FSDataOutputStream Create(Path f, bool overwrite, bool createParent, int bufferSize, short replication, long blockSize, Progressable progress, FsPermission permission) { if (Exists(f) && !overwrite) { throw new FileAlreadyExistsException("File already exists: " + f); } Path parent = f.GetParent(); if (parent != null && !Mkdirs(parent)) { throw new IOException("Mkdirs failed to create " + parent.ToString()); } return(new FSDataOutputStream(new BufferedOutputStream(CreateOutputStreamWithMode (f, false, permission), bufferSize), statistics)); }
/// <exception cref="System.IO.IOException"/> private FSDataOutputStream Create(Path f, FsPermission permission, bool overwrite , bool createParent, int bufferSize, short replication, long blockSize, Progressable progress) { Path parent = f.GetParent(); if (parent != null) { if (!createParent && !Exists(parent)) { throw new FileNotFoundException("Parent directory doesn't exist: " + parent); } else { if (!Mkdirs(parent)) { throw new IOException("Mkdirs failed to create " + parent + " (exists=" + Exists( parent) + ", cwd=" + GetWorkingDirectory() + ")"); } } } FSDataOutputStream @out; if (writeChecksum) { @out = new FSDataOutputStream(new ChecksumFileSystem.ChecksumFSOutputSummer(this, f, overwrite, bufferSize, replication, blockSize, progress, permission), null); } else { @out = fs.Create(f, permission, overwrite, bufferSize, replication, blockSize, progress ); // remove the checksum file since we aren't writing one Path checkFile = GetChecksumFile(f); if (fs.Exists(checkFile)) { fs.Delete(checkFile, true); } } return(@out); }
/// <exception cref="System.IO.IOException"/> private Path CreatePath(string path, bool checkWrite) { Path file = new Path(new Path(localDirs[dirNumLastAccessed]), path); if (checkWrite) { //check whether we are able to create a directory here. If the disk //happens to be RDONLY we will fail try { DiskChecker.CheckDir(new FilePath(file.GetParent().ToUri().GetPath())); return(file); } catch (DiskChecker.DiskErrorException d) { Log.Warn("Disk Error Exception: ", d); return(null); } } return(file); }
/// <summary> /// Test trash for the shell's delete command for the default file system /// specified in the paramter conf /// </summary> /// <param name="conf"></param> /// <param name="base">- the base path where files are created</param> /// <param name="trashRoot">- the expected place where the trashbin resides</param> /// <exception cref="System.IO.IOException"/> public static void TrashShell(Configuration conf, Path @base, FileSystem trashRootFs , Path trashRoot) { FileSystem fs = FileSystem.Get(conf); conf.SetLong(FsTrashIntervalKey, 0); // disabled NUnit.Framework.Assert.IsFalse(new Trash(conf).IsEnabled()); conf.SetLong(FsTrashIntervalKey, 10); // 10 minute Assert.True(new Trash(conf).IsEnabled()); FsShell shell = new FsShell(); shell.SetConf(conf); if (trashRoot == null) { trashRoot = shell.GetCurrentTrashDir(); } if (trashRootFs == null) { trashRootFs = fs; } // First create a new directory with mkdirs Path myPath = new Path(@base, "test/mkdirs"); Mkdir(fs, myPath); // Second, create a file in that directory. Path myFile = new Path(@base, "test/mkdirs/myFile"); FileSystemTestHelper.WriteFile(fs, myFile, 10); { // Verify that expunge without Trash directory // won't throw Exception string[] args = new string[1]; args[0] = "-expunge"; int val = -1; try { val = shell.Run(args); } catch (Exception e) { System.Console.Error.WriteLine("Exception raised from Trash.run " + e.GetLocalizedMessage ()); } Assert.True(val == 0); } { // Verify that we succeed in removing the file we created. // This should go into Trash. string[] args = new string[2]; args[0] = "-rm"; args[1] = myFile.ToString(); int val = -1; try { val = shell.Run(args); } catch (Exception e) { System.Console.Error.WriteLine("Exception raised from Trash.run " + e.GetLocalizedMessage ()); } Assert.True(val == 0); CheckTrash(trashRootFs, trashRoot, fs.MakeQualified(myFile)); } // Verify that we can recreate the file FileSystemTestHelper.WriteFile(fs, myFile, 10); { // Verify that we succeed in removing the file we re-created string[] args = new string[2]; args[0] = "-rm"; args[1] = new Path(@base, "test/mkdirs/myFile").ToString(); int val = -1; try { val = shell.Run(args); } catch (Exception e) { System.Console.Error.WriteLine("Exception raised from Trash.run " + e.GetLocalizedMessage ()); } Assert.True(val == 0); } // Verify that we can recreate the file FileSystemTestHelper.WriteFile(fs, myFile, 10); { // Verify that we succeed in removing the whole directory // along with the file inside it. string[] args = new string[2]; args[0] = "-rmr"; args[1] = new Path(@base, "test/mkdirs").ToString(); int val = -1; try { val = shell.Run(args); } catch (Exception e) { System.Console.Error.WriteLine("Exception raised from Trash.run " + e.GetLocalizedMessage ()); } Assert.True(val == 0); } // recreate directory Mkdir(fs, myPath); { // Verify that we succeed in removing the whole directory string[] args = new string[2]; args[0] = "-rmr"; args[1] = new Path(@base, "test/mkdirs").ToString(); int val = -1; try { val = shell.Run(args); } catch (Exception e) { System.Console.Error.WriteLine("Exception raised from Trash.run " + e.GetLocalizedMessage ()); } Assert.True(val == 0); } { // Check that we can delete a file from the trash Path toErase = new Path(trashRoot, "toErase"); int retVal = -1; FileSystemTestHelper.WriteFile(trashRootFs, toErase, 10); try { retVal = shell.Run(new string[] { "-rm", toErase.ToString() }); } catch (Exception e) { System.Console.Error.WriteLine("Exception raised from Trash.run " + e.GetLocalizedMessage ()); } Assert.True(retVal == 0); CheckNotInTrash(trashRootFs, trashRoot, toErase.ToString()); CheckNotInTrash(trashRootFs, trashRoot, toErase.ToString() + ".1"); } { // simulate Trash removal string[] args = new string[1]; args[0] = "-expunge"; int val = -1; try { val = shell.Run(args); } catch (Exception e) { System.Console.Error.WriteLine("Exception raised from Trash.run " + e.GetLocalizedMessage ()); } Assert.True(val == 0); } // verify that after expunging the Trash, it really goes away CheckNotInTrash(trashRootFs, trashRoot, new Path(@base, "test/mkdirs/myFile").ToString ()); // recreate directory and file Mkdir(fs, myPath); FileSystemTestHelper.WriteFile(fs, myFile, 10); { // remove file first, then remove directory string[] args = new string[2]; args[0] = "-rm"; args[1] = myFile.ToString(); int val = -1; try { val = shell.Run(args); } catch (Exception e) { System.Console.Error.WriteLine("Exception raised from Trash.run " + e.GetLocalizedMessage ()); } Assert.True(val == 0); CheckTrash(trashRootFs, trashRoot, myFile); args = new string[2]; args[0] = "-rmr"; args[1] = myPath.ToString(); val = -1; try { val = shell.Run(args); } catch (Exception e) { System.Console.Error.WriteLine("Exception raised from Trash.run " + e.GetLocalizedMessage ()); } Assert.True(val == 0); CheckTrash(trashRootFs, trashRoot, myPath); } { // attempt to remove parent of trash string[] args = new string[2]; args[0] = "-rmr"; args[1] = trashRoot.GetParent().GetParent().ToString(); int val = -1; try { val = shell.Run(args); } catch (Exception e) { System.Console.Error.WriteLine("Exception raised from Trash.run " + e.GetLocalizedMessage ()); } Assert.Equal("exit code", 1, val); Assert.True(trashRootFs.Exists(trashRoot)); } // Verify skip trash option really works // recreate directory and file Mkdir(fs, myPath); FileSystemTestHelper.WriteFile(fs, myFile, 10); { // Verify that skip trash option really skips the trash for files (rm) string[] args = new string[3]; args[0] = "-rm"; args[1] = "-skipTrash"; args[2] = myFile.ToString(); int val = -1; try { // Clear out trash Assert.Equal("-expunge failed", 0, shell.Run(new string[] { "-expunge" })); val = shell.Run(args); } catch (Exception e) { System.Console.Error.WriteLine("Exception raised from Trash.run " + e.GetLocalizedMessage ()); } NUnit.Framework.Assert.IsFalse("Expected TrashRoot (" + trashRoot + ") to exist in file system:" + trashRootFs.GetUri(), trashRootFs.Exists(trashRoot)); // No new Current should be created NUnit.Framework.Assert.IsFalse(fs.Exists(myFile)); Assert.True(val == 0); } // recreate directory and file Mkdir(fs, myPath); FileSystemTestHelper.WriteFile(fs, myFile, 10); { // Verify that skip trash option really skips the trash for rmr string[] args = new string[3]; args[0] = "-rmr"; args[1] = "-skipTrash"; args[2] = myPath.ToString(); int val = -1; try { // Clear out trash Assert.Equal(0, shell.Run(new string[] { "-expunge" })); val = shell.Run(args); } catch (Exception e) { System.Console.Error.WriteLine("Exception raised from Trash.run " + e.GetLocalizedMessage ()); } NUnit.Framework.Assert.IsFalse(trashRootFs.Exists(trashRoot)); // No new Current should be created NUnit.Framework.Assert.IsFalse(fs.Exists(myPath)); NUnit.Framework.Assert.IsFalse(fs.Exists(myFile)); Assert.True(val == 0); } { // deleting same file multiple times int val = -1; Mkdir(fs, myPath); try { Assert.Equal(0, shell.Run(new string[] { "-expunge" })); } catch (Exception e) { System.Console.Error.WriteLine("Exception raised from fs expunge " + e.GetLocalizedMessage ()); } // create a file in that directory. myFile = new Path(@base, "test/mkdirs/myFile"); string[] args = new string[] { "-rm", myFile.ToString() }; int num_runs = 10; for (int i = 0; i < num_runs; i++) { //create file FileSystemTestHelper.WriteFile(fs, myFile, 10); // delete file try { val = shell.Run(args); } catch (Exception e) { System.Console.Error.WriteLine("Exception raised from Trash.run " + e.GetLocalizedMessage ()); } Assert.True(val == 0); } // current trash directory Path trashDir = Path.MergePaths(new Path(trashRoot.ToUri().GetPath()), new Path(myFile .GetParent().ToUri().GetPath())); System.Console.Out.WriteLine("Deleting same myFile: myFile.parent=" + myFile.GetParent ().ToUri().GetPath() + "; trashroot=" + trashRoot.ToUri().GetPath() + "; trashDir=" + trashDir.ToUri().GetPath()); int count = CountSameDeletedFiles(fs, trashDir, myFile); System.Console.Out.WriteLine("counted " + count + " files " + myFile.GetName() + "* in " + trashDir); Assert.True(count == num_runs); } { //Verify skipTrash option is suggested when rm fails due to its absence string[] args = new string[2]; args[0] = "-rmr"; args[1] = "/"; //This always contains trash directory TextWriter stdout = System.Console.Out; TextWriter stderr = System.Console.Error; ByteArrayOutputStream byteStream = new ByteArrayOutputStream(); TextWriter newOut = new TextWriter(byteStream); Runtime.SetOut(newOut); Runtime.SetErr(newOut); try { shell.Run(args); } catch (Exception e) { System.Console.Error.WriteLine("Exception raised from Trash.run " + e.GetLocalizedMessage ()); } string output = byteStream.ToString(); Runtime.SetOut(stdout); Runtime.SetErr(stderr); Assert.True("skipTrash wasn't suggested as remedy to failed rm command" + " or we deleted / even though we could not get server defaults", output.IndexOf ("Consider using -skipTrash option") != -1 || output.IndexOf("Failed to determine server trash configuration" ) != -1); } { // Verify old checkpoint format is recognized // emulate two old trash checkpoint directories, one that is old enough // to be deleted on the next expunge and one that isn't. long trashInterval = conf.GetLong(FsTrashIntervalKey, FsTrashIntervalDefault); long now = Time.Now(); DateFormat oldCheckpointFormat = new SimpleDateFormat("yyMMddHHmm"); Path dirToDelete = new Path(trashRoot.GetParent(), oldCheckpointFormat.Format(now - (trashInterval * 60 * 1000) - 1)); Path dirToKeep = new Path(trashRoot.GetParent(), oldCheckpointFormat.Format(now)); Mkdir(trashRootFs, dirToDelete); Mkdir(trashRootFs, dirToKeep); // Clear out trash int rc = -1; try { rc = shell.Run(new string[] { "-expunge" }); } catch (Exception e) { System.Console.Error.WriteLine("Exception raised from fs expunge " + e.GetLocalizedMessage ()); } Assert.Equal(0, rc); NUnit.Framework.Assert.IsFalse("old checkpoint format not recognized", trashRootFs .Exists(dirToDelete)); Assert.True("old checkpoint format directory should not be removed" , trashRootFs.Exists(dirToKeep)); } }
/// <summary>Return the name of the checksum file associated with a file.</summary> public virtual Path GetChecksumFile(Path file) { return(new Path(file.GetParent(), "." + file.GetName() + ".crc")); }
/// <exception cref="System.Exception"/> public virtual void TestTrashEmptier() { Configuration conf = new Configuration(); // Trash with 12 second deletes and 6 seconds checkpoints conf.Set(FsTrashIntervalKey, "0.2"); // 12 seconds conf.SetClass("fs.file.impl", typeof(TestTrash.TestLFS), typeof(FileSystem)); conf.Set(FsTrashCheckpointIntervalKey, "0.1"); // 6 seconds FileSystem fs = FileSystem.GetLocal(conf); conf.Set("fs.default.name", fs.GetUri().ToString()); Trash trash = new Trash(conf); // Start Emptier in background Runnable emptier = trash.GetEmptier(); Thread emptierThread = new Thread(emptier); emptierThread.Start(); FsShell shell = new FsShell(); shell.SetConf(conf); shell.Init(); // First create a new directory with mkdirs Path myPath = new Path(TestDir, "test/mkdirs"); Mkdir(fs, myPath); int fileIndex = 0; ICollection <string> checkpoints = new HashSet <string>(); while (true) { // Create a file with a new name Path myFile = new Path(TestDir, "test/mkdirs/myFile" + fileIndex++); FileSystemTestHelper.WriteFile(fs, myFile, 10); // Delete the file to trash string[] args = new string[2]; args[0] = "-rm"; args[1] = myFile.ToString(); int val = -1; try { val = shell.Run(args); } catch (Exception e) { System.Console.Error.WriteLine("Exception raised from Trash.run " + e.GetLocalizedMessage ()); } Assert.True(val == 0); Path trashDir = shell.GetCurrentTrashDir(); FileStatus[] files = fs.ListStatus(trashDir.GetParent()); // Scan files in .Trash and add them to set of checkpoints foreach (FileStatus file in files) { string fileName = file.GetPath().GetName(); checkpoints.AddItem(fileName); } // If checkpoints has 4 objects it is Current + 3 checkpoint directories if (checkpoints.Count == 4) { // The actual contents should be smaller since the last checkpoint // should've been deleted and Current might not have been recreated yet Assert.True(checkpoints.Count > files.Length); break; } Thread.Sleep(5000); } emptierThread.Interrupt(); emptierThread.Join(); }