/// <exception cref="System.IO.IOException"></exception> internal virtual ByteWindow Mmap(long pos, int size) { lock (readLock) { if (length < pos + size) { size = (int)(length - pos); } MappedByteBuffer map; try { map = fd.GetChannel().Map(FileChannel.MapMode.READ_ONLY, pos, size); } catch (IOException) { // The most likely reason this failed is the JVM has run out // of virtual memory. We need to discard quickly, and try to // force the GC to finalize and release any existing mappings. // System.GC.Collect(); System.GC.WaitForPendingFinalizers(); map = fd.GetChannel().Map(FileChannel.MapMode.READ_ONLY, pos, size); } if (map.HasArray()) { return(new ByteArrayWindow(this, pos, ((byte[])map.Array()))); } return(new ByteBufferWindow(this, pos, map)); } }
/// <exception cref="System.IO.IOException"/> public FadvisedFileRegion(RandomAccessFile file, long position, long count, bool manageOsCache, int readaheadLength, ReadaheadPool readaheadPool, string identifier , int shuffleBufferSize, bool shuffleTransferToAllowed) : base(file.GetChannel(), position, count) { this.manageOsCache = manageOsCache; this.readaheadLength = readaheadLength; this.readaheadPool = readaheadPool; this.fd = file.GetFD(); this.identifier = identifier; this.fileChannel = file.GetChannel(); this.count = count; this.position = position; this.shuffleBufferSize = shuffleBufferSize; this.shuffleTransferToAllowed = shuffleTransferToAllowed; }
/// <exception cref="System.IO.IOException"></exception> public override PackLock Parse(ProgressMonitor receiving, ProgressMonitor resolving ) { tmpPack = FilePath.CreateTempFile("incoming_", ".pack", db.GetDirectory()); tmpIdx = new FilePath(db.GetDirectory(), BaseName(tmpPack) + ".idx"); try { @out = new RandomAccessFile(tmpPack, "rw"); base.Parse(receiving, resolving); @out.Seek(packEnd); @out.Write(packHash); @out.GetChannel().Force(true); @out.Close(); WriteIdx(); tmpPack.SetReadOnly(); tmpIdx.SetReadOnly(); return(RenameAndOpenPack(GetLockMessage())); } finally { if (def != null) { def.Finish(); } try { if (@out != null && @out.GetChannel().IsOpen()) { @out.Close(); } } catch (IOException) { } // Ignored. We want to delete the file. CleanupTemporaryFiles(); } }
public virtual void TestWriteFully() { int InputBufferLen = 10000; int Halfway = 1 + (InputBufferLen / 2); byte[] input = new byte[InputBufferLen]; for (int i = 0; i < input.Length; i++) { input[i] = unchecked ((byte)(i & unchecked ((int)(0xff)))); } byte[] output = new byte[input.Length]; try { RandomAccessFile raf = new RandomAccessFile(TestFileName, "rw"); FileChannel fc = raf.GetChannel(); ByteBuffer buf = ByteBuffer.Wrap(input); IOUtils.WriteFully(fc, buf); raf.Seek(0); raf.Read(output); for (int i_1 = 0; i_1 < input.Length; i_1++) { Assert.Equal(input[i_1], output[i_1]); } buf.Rewind(); IOUtils.WriteFully(fc, buf, Halfway); for (int i_2 = 0; i_2 < Halfway; i_2++) { Assert.Equal(input[i_2], output[i_2]); } raf.Seek(0); raf.Read(output); for (int i_3 = Halfway; i_3 < input.Length; i_3++) { Assert.Equal(input[i_3 - Halfway], output[i_3]); } } finally { FilePath f = new FilePath(TestFileName); if (f.Exists()) { f.Delete(); } } }
private string InitHostPort() { Basetest.Mkdirs(); int port; for (; ;) { port = PortAssignment.Unique(); FileLock Lock = null; portNumLockFile = null; try { try { portNumFile = new FilePath(Basetest, port + ".lock"); portNumLockFile = new RandomAccessFile(portNumFile, "rw"); try { Lock = portNumLockFile.GetChannel().TryLock(); } catch (OverlappingFileLockException) { continue; } } finally { if (Lock != null) { break; } if (portNumLockFile != null) { portNumLockFile.Close(); } } } catch (IOException e) { throw new RuntimeException(e); } } return("127.0.0.1:" + port); }
/// <summary>Read the cache file into memory.</summary> /// <remarks>Read the cache file into memory.</remarks> /// <exception cref="System.IO.IOException">System.IO.IOException</exception> public virtual void Read() { changed = false; statDirty = false; if (!cacheFile.Exists()) { header = null; entries.Clear(); lastCacheTime = 0; return; } cache = new RandomAccessFile(cacheFile, "r"); try { FileChannel channel = cache.GetChannel(); ByteBuffer buffer = ByteBuffer.AllocateDirect((int)cacheFile.Length()); buffer.Order(ByteOrder.BIG_ENDIAN); int j = channel.Read(buffer); if (j != buffer.Capacity()) { throw new IOException(MessageFormat.Format(JGitText.Get().couldNotReadIndexInOneGo , j, buffer.Capacity())); } buffer.Flip(); header = new GitIndex.Header(buffer); entries.Clear(); for (int i = 0; i < header.entries; ++i) { GitIndex.Entry entry = new GitIndex.Entry(this, buffer); GitIndex.Entry existing = entries.Get(entry.name); entries.Put(entry.name, entry); if (existing != null) { entry.stages |= existing.stages; } } lastCacheTime = cacheFile.LastModified(); } finally { cache.Close(); } }
/// <exception cref="System.IO.IOException"/> private void LazyOpen() { if (ch != null) { return; } // Load current value. byte[] data = null; try { data = Files.ToByteArray(file); } catch (FileNotFoundException) { } // Expected - this will use default value. if (data != null && data.Length != 0) { if (data.Length != Longs.Bytes) { throw new IOException("File " + file + " had invalid length: " + data.Length); } value = Longs.FromByteArray(data); } else { value = defaultVal; } // Now open file for future writes. RandomAccessFile raf = new RandomAccessFile(file, "rw"); try { ch = raf.GetChannel(); } finally { if (ch == null) { IOUtils.CloseStream(raf); } } }
/// <summary> /// Asserts that the storage lock file in the given directory has been /// released. /// </summary> /// <remarks> /// Asserts that the storage lock file in the given directory has been /// released. This method works by trying to acquire the lock file itself. If /// locking fails here, then the main code must have failed to release it. /// </remarks> /// <param name="dir">the storage directory to check</param> /// <exception cref="System.IO.IOException">if there is an unexpected I/O error</exception> public static void AssertFileLockReleased(string dir) { StorageLocation sl = StorageLocation.Parse(dir); FilePath lockFile = new FilePath(sl.GetFile(), Storage.StorageFileLock); try { using (RandomAccessFile raf = new RandomAccessFile(lockFile, "rws")) { using (FileChannel channel = raf.GetChannel()) { FileLock Lock = channel.TryLock(); NUnit.Framework.Assert.IsNotNull(string.Format("Lock file at %s appears to be held by a different process." , lockFile.GetAbsolutePath()), Lock); if (Lock != null) { try { Lock.Release(); } catch (IOException e) { FsDatasetImpl.Log.Warn(string.Format("I/O error releasing file lock %s.", lockFile .GetAbsolutePath()), e); throw; } } } } } catch (OverlappingFileLockException) { NUnit.Framework.Assert.Fail(string.Format("Must release lock file at %s.", lockFile .GetAbsolutePath())); } }
/// <exception cref="System.Exception"/> public virtual void TestCopyFileUnbuffered() { string MethodName = GenericTestUtils.GetMethodName(); FilePath srcFile = new FilePath(TestDir, MethodName + ".src.dat"); FilePath dstFile = new FilePath(TestDir, MethodName + ".dst.dat"); int fileSize = unchecked ((int)(0x8000000)); // 128 MB int Seed = unchecked ((int)(0xBEEF)); int batchSize = 4096; int numBatches = fileSize / batchSize; Random rb = new Random(Seed); FileChannel channel = null; RandomAccessFile raSrcFile = null; try { raSrcFile = new RandomAccessFile(srcFile, "rw"); channel = raSrcFile.GetChannel(); byte[] bytesToWrite = new byte[batchSize]; MappedByteBuffer mapBuf; mapBuf = channel.Map(FileChannel.MapMode.ReadWrite, 0, fileSize); for (int i = 0; i < numBatches; i++) { rb.NextBytes(bytesToWrite); mapBuf.Put(bytesToWrite); } NativeIO.CopyFileUnbuffered(srcFile, dstFile); Assert.Equal(srcFile.Length(), dstFile.Length()); } finally { IOUtils.Cleanup(Log, channel); IOUtils.Cleanup(Log, raSrcFile); FileUtils.DeleteQuietly(TestDir); } }
/// <summary>check if DFS can handle corrupted CRC blocks</summary> /// <exception cref="System.Exception"/> private void Thistest(Configuration conf, DFSTestUtil util) { MiniDFSCluster cluster = null; int numDataNodes = 2; short replFactor = 2; Random random = new Random(); // Set short retry timeouts so this test runs faster conf.SetInt(DFSConfigKeys.DfsClientRetryWindowBase, 10); try { cluster = new MiniDFSCluster.Builder(conf).NumDataNodes(numDataNodes).Build(); cluster.WaitActive(); FileSystem fs = cluster.GetFileSystem(); util.CreateFiles(fs, "/srcdat", replFactor); util.WaitReplication(fs, "/srcdat", (short)2); // Now deliberately remove/truncate meta blocks from the first // directory of the first datanode. The complete absense of a meta // file disallows this Datanode to send data to another datanode. // However, a client is alowed access to this block. // FilePath storageDir = cluster.GetInstanceStorageDir(0, 1); string bpid = cluster.GetNamesystem().GetBlockPoolId(); FilePath data_dir = MiniDFSCluster.GetFinalizedDir(storageDir, bpid); NUnit.Framework.Assert.IsTrue("data directory does not exist", data_dir.Exists()); FilePath[] blocks = data_dir.ListFiles(); NUnit.Framework.Assert.IsTrue("Blocks do not exist in data-dir", (blocks != null) && (blocks.Length > 0)); int num = 0; for (int idx = 0; idx < blocks.Length; idx++) { if (blocks[idx].GetName().StartsWith(Block.BlockFilePrefix) && blocks[idx].GetName ().EndsWith(".meta")) { num++; if (num % 3 == 0) { // // remove .meta file // System.Console.Out.WriteLine("Deliberately removing file " + blocks[idx].GetName( )); NUnit.Framework.Assert.IsTrue("Cannot remove file.", blocks[idx].Delete()); } else { if (num % 3 == 1) { // // shorten .meta file // RandomAccessFile file = new RandomAccessFile(blocks[idx], "rw"); FileChannel channel = file.GetChannel(); int newsize = random.Next((int)channel.Size() / 2); System.Console.Out.WriteLine("Deliberately truncating file " + blocks[idx].GetName () + " to size " + newsize + " bytes."); channel.Truncate(newsize); file.Close(); } else { // // corrupt a few bytes of the metafile // RandomAccessFile file = new RandomAccessFile(blocks[idx], "rw"); FileChannel channel = file.GetChannel(); long position = 0; // // The very first time, corrupt the meta header at offset 0 // if (num != 2) { position = (long)random.Next((int)channel.Size()); } int length = random.Next((int)(channel.Size() - position + 1)); byte[] buffer = new byte[length]; random.NextBytes(buffer); channel.Write(ByteBuffer.Wrap(buffer), position); System.Console.Out.WriteLine("Deliberately corrupting file " + blocks[idx].GetName () + " at offset " + position + " length " + length); file.Close(); } } } } // // Now deliberately corrupt all meta blocks from the second // directory of the first datanode // storageDir = cluster.GetInstanceStorageDir(0, 1); data_dir = MiniDFSCluster.GetFinalizedDir(storageDir, bpid); NUnit.Framework.Assert.IsTrue("data directory does not exist", data_dir.Exists()); blocks = data_dir.ListFiles(); NUnit.Framework.Assert.IsTrue("Blocks do not exist in data-dir", (blocks != null) && (blocks.Length > 0)); int count = 0; FilePath previous = null; for (int idx_1 = 0; idx_1 < blocks.Length; idx_1++) { if (blocks[idx_1].GetName().StartsWith("blk_") && blocks[idx_1].GetName().EndsWith (".meta")) { // // Move the previous metafile into the current one. // count++; if (count % 2 == 0) { System.Console.Out.WriteLine("Deliberately insertimg bad crc into files " + blocks [idx_1].GetName() + " " + previous.GetName()); NUnit.Framework.Assert.IsTrue("Cannot remove file.", blocks[idx_1].Delete()); NUnit.Framework.Assert.IsTrue("Cannot corrupt meta file.", previous.RenameTo(blocks [idx_1])); NUnit.Framework.Assert.IsTrue("Cannot recreate empty meta file.", previous.CreateNewFile ()); previous = null; } else { previous = blocks[idx_1]; } } } // // Only one replica is possibly corrupted. The other replica should still // be good. Verify. // NUnit.Framework.Assert.IsTrue("Corrupted replicas not handled properly.", util.CheckFiles (fs, "/srcdat")); System.Console.Out.WriteLine("All File still have a valid replica"); // // set replication factor back to 1. This causes only one replica of // of each block to remain in HDFS. The check is to make sure that // the corrupted replica generated above is the one that gets deleted. // This test is currently disabled until HADOOP-1557 is solved. // util.SetReplication(fs, "/srcdat", (short)1); //util.waitReplication(fs, "/srcdat", (short)1); //System.out.println("All Files done with removing replicas"); //assertTrue("Excess replicas deleted. Corrupted replicas found.", // util.checkFiles(fs, "/srcdat")); System.Console.Out.WriteLine("The excess-corrupted-replica test is disabled " + " pending HADOOP-1557" ); util.Cleanup(fs, "/srcdat"); } finally { if (cluster != null) { cluster.Shutdown(); } } }
/// <summary>check if nn.getCorruptFiles() returns a file that has corrupted blocks</summary> /// <exception cref="System.Exception"/> public virtual void TestListCorruptFilesCorruptedBlock() { MiniDFSCluster cluster = null; Random random = new Random(); try { Configuration conf = new HdfsConfiguration(); conf.SetInt(DFSConfigKeys.DfsDatanodeDirectoryscanIntervalKey, 1); // datanode scans directories conf.SetInt(DFSConfigKeys.DfsBlockreportIntervalMsecKey, 3 * 1000); // datanode sends block reports // Set short retry timeouts so this test runs faster conf.SetInt(DFSConfigKeys.DfsClientRetryWindowBase, 10); cluster = new MiniDFSCluster.Builder(conf).Build(); FileSystem fs = cluster.GetFileSystem(); // create two files with one block each DFSTestUtil util = new DFSTestUtil.Builder().SetName("testCorruptFilesCorruptedBlock" ).SetNumFiles(2).SetMaxLevels(1).SetMaxSize(512).Build(); util.CreateFiles(fs, "/srcdat10"); // fetch bad file list from namenode. There should be none. NameNode namenode = cluster.GetNameNode(); ICollection <FSNamesystem.CorruptFileBlockInfo> badFiles = namenode.GetNamesystem( ).ListCorruptFileBlocks("/", null); NUnit.Framework.Assert.IsTrue("Namenode has " + badFiles.Count + " corrupt files. Expecting None." , badFiles.Count == 0); // Now deliberately corrupt one block string bpid = cluster.GetNamesystem().GetBlockPoolId(); FilePath storageDir = cluster.GetInstanceStorageDir(0, 1); FilePath data_dir = MiniDFSCluster.GetFinalizedDir(storageDir, bpid); NUnit.Framework.Assert.IsTrue("data directory does not exist", data_dir.Exists()); IList <FilePath> metaFiles = MiniDFSCluster.GetAllBlockMetadataFiles(data_dir); NUnit.Framework.Assert.IsTrue("Data directory does not contain any blocks or there was an " + "IO error", metaFiles != null && !metaFiles.IsEmpty()); FilePath metaFile = metaFiles[0]; RandomAccessFile file = new RandomAccessFile(metaFile, "rw"); FileChannel channel = file.GetChannel(); long position = channel.Size() - 2; int length = 2; byte[] buffer = new byte[length]; random.NextBytes(buffer); channel.Write(ByteBuffer.Wrap(buffer), position); file.Close(); Log.Info("Deliberately corrupting file " + metaFile.GetName() + " at offset " + position + " length " + length); // read all files to trigger detection of corrupted replica try { util.CheckFiles(fs, "/srcdat10"); } catch (BlockMissingException) { System.Console.Out.WriteLine("Received BlockMissingException as expected."); } catch (IOException e) { NUnit.Framework.Assert.IsTrue("Corrupted replicas not handled properly. Expecting BlockMissingException " + " but received IOException " + e, false); } // fetch bad file list from namenode. There should be one file. badFiles = namenode.GetNamesystem().ListCorruptFileBlocks("/", null); Log.Info("Namenode has bad files. " + badFiles.Count); NUnit.Framework.Assert.IsTrue("Namenode has " + badFiles.Count + " bad files. Expecting 1." , badFiles.Count == 1); util.Cleanup(fs, "/srcdat10"); } finally { if (cluster != null) { cluster.Shutdown(); } } }
/// <summary>Check that listCorruptFileBlocks works while the namenode is still in safemode. /// </summary> /// <exception cref="System.Exception"/> public virtual void TestListCorruptFileBlocksInSafeMode() { MiniDFSCluster cluster = null; Random random = new Random(); try { Configuration conf = new HdfsConfiguration(); // datanode scans directories conf.SetInt(DFSConfigKeys.DfsDatanodeDirectoryscanIntervalKey, 1); // datanode sends block reports conf.SetInt(DFSConfigKeys.DfsBlockreportIntervalMsecKey, 3 * 1000); // never leave safemode automatically conf.SetFloat(DFSConfigKeys.DfsNamenodeSafemodeThresholdPctKey, 1.5f); // start populating repl queues immediately conf.SetFloat(DFSConfigKeys.DfsNamenodeReplQueueThresholdPctKey, 0f); // Set short retry timeouts so this test runs faster conf.SetInt(DFSConfigKeys.DfsClientRetryWindowBase, 10); cluster = new MiniDFSCluster.Builder(conf).WaitSafeMode(false).Build(); cluster.GetNameNodeRpc().SetSafeMode(HdfsConstants.SafeModeAction.SafemodeLeave, false); FileSystem fs = cluster.GetFileSystem(); // create two files with one block each DFSTestUtil util = new DFSTestUtil.Builder().SetName("testListCorruptFileBlocksInSafeMode" ).SetNumFiles(2).SetMaxLevels(1).SetMaxSize(512).Build(); util.CreateFiles(fs, "/srcdat10"); // fetch bad file list from namenode. There should be none. ICollection <FSNamesystem.CorruptFileBlockInfo> badFiles = cluster.GetNameNode().GetNamesystem ().ListCorruptFileBlocks("/", null); NUnit.Framework.Assert.IsTrue("Namenode has " + badFiles.Count + " corrupt files. Expecting None." , badFiles.Count == 0); // Now deliberately corrupt one block FilePath storageDir = cluster.GetInstanceStorageDir(0, 0); FilePath data_dir = MiniDFSCluster.GetFinalizedDir(storageDir, cluster.GetNamesystem ().GetBlockPoolId()); NUnit.Framework.Assert.IsTrue("data directory does not exist", data_dir.Exists()); IList <FilePath> metaFiles = MiniDFSCluster.GetAllBlockMetadataFiles(data_dir); NUnit.Framework.Assert.IsTrue("Data directory does not contain any blocks or there was an " + "IO error", metaFiles != null && !metaFiles.IsEmpty()); FilePath metaFile = metaFiles[0]; RandomAccessFile file = new RandomAccessFile(metaFile, "rw"); FileChannel channel = file.GetChannel(); long position = channel.Size() - 2; int length = 2; byte[] buffer = new byte[length]; random.NextBytes(buffer); channel.Write(ByteBuffer.Wrap(buffer), position); file.Close(); Log.Info("Deliberately corrupting file " + metaFile.GetName() + " at offset " + position + " length " + length); // read all files to trigger detection of corrupted replica try { util.CheckFiles(fs, "/srcdat10"); } catch (BlockMissingException) { System.Console.Out.WriteLine("Received BlockMissingException as expected."); } catch (IOException e) { NUnit.Framework.Assert.IsTrue("Corrupted replicas not handled properly. " + "Expecting BlockMissingException " + " but received IOException " + e, false); } // fetch bad file list from namenode. There should be one file. badFiles = cluster.GetNameNode().GetNamesystem().ListCorruptFileBlocks("/", null); Log.Info("Namenode has bad files. " + badFiles.Count); NUnit.Framework.Assert.IsTrue("Namenode has " + badFiles.Count + " bad files. Expecting 1." , badFiles.Count == 1); // restart namenode cluster.RestartNameNode(0); fs = cluster.GetFileSystem(); // wait until replication queues have been initialized while (!cluster.GetNameNode().namesystem.IsPopulatingReplQueues()) { try { Log.Info("waiting for replication queues"); Sharpen.Thread.Sleep(1000); } catch (Exception) { } } // read all files to trigger detection of corrupted replica try { util.CheckFiles(fs, "/srcdat10"); } catch (BlockMissingException) { System.Console.Out.WriteLine("Received BlockMissingException as expected."); } catch (IOException e) { NUnit.Framework.Assert.IsTrue("Corrupted replicas not handled properly. " + "Expecting BlockMissingException " + " but received IOException " + e, false); } // fetch bad file list from namenode. There should be one file. badFiles = cluster.GetNameNode().GetNamesystem().ListCorruptFileBlocks("/", null); Log.Info("Namenode has bad files. " + badFiles.Count); NUnit.Framework.Assert.IsTrue("Namenode has " + badFiles.Count + " bad files. Expecting 1." , badFiles.Count == 1); // check that we are still in safe mode NUnit.Framework.Assert.IsTrue("Namenode is not in safe mode", cluster.GetNameNode ().IsInSafeMode()); // now leave safe mode so that we can clean up cluster.GetNameNodeRpc().SetSafeMode(HdfsConstants.SafeModeAction.SafemodeLeave, false); util.Cleanup(fs, "/srcdat10"); } catch (Exception e) { Log.Error(StringUtils.StringifyException(e)); throw; } finally { if (cluster != null) { cluster.Shutdown(); } } }
/// <exception cref="System.IO.IOException"/> public virtual void TestCustomShuffleTransfer() { FilePath absLogDir = new FilePath("target", typeof(TestFadvisedFileRegion).Name + "LocDir").GetAbsoluteFile(); string testDirPath = StringUtils.Join(Path.Separator, new string[] { absLogDir.GetAbsolutePath (), "testCustomShuffleTransfer" }); FilePath testDir = new FilePath(testDirPath); testDir.Mkdirs(); System.Console.Out.WriteLine(testDir.GetAbsolutePath()); FilePath inFile = new FilePath(testDir, "fileIn.out"); FilePath outFile = new FilePath(testDir, "fileOut.out"); //Initialize input file byte[] initBuff = new byte[FileSize]; Random rand = new Random(); rand.NextBytes(initBuff); FileOutputStream @out = new FileOutputStream(inFile); try { @out.Write(initBuff); } finally { IOUtils.Cleanup(Log, @out); } //define position and count to read from a file region. int position = 2 * 1024 * 1024; int count = 4 * 1024 * 1024 - 1; RandomAccessFile inputFile = null; RandomAccessFile targetFile = null; WritableByteChannel target = null; FadvisedFileRegion fileRegion = null; try { inputFile = new RandomAccessFile(inFile.GetAbsolutePath(), "r"); targetFile = new RandomAccessFile(outFile.GetAbsolutePath(), "rw"); target = targetFile.GetChannel(); NUnit.Framework.Assert.AreEqual(FileSize, inputFile.Length()); //create FadvisedFileRegion fileRegion = new FadvisedFileRegion(inputFile, position, count, false, 0, null, null , 1024, false); //test corner cases CustomShuffleTransferCornerCases(fileRegion, target, count); long pos = 0; long size; while ((size = fileRegion.CustomShuffleTransfer(target, pos)) > 0) { pos += size; } //assert size NUnit.Framework.Assert.AreEqual(count, (int)pos); NUnit.Framework.Assert.AreEqual(count, targetFile.Length()); } finally { if (fileRegion != null) { fileRegion.ReleaseExternalResources(); } IOUtils.Cleanup(Log, target); IOUtils.Cleanup(Log, targetFile); IOUtils.Cleanup(Log, inputFile); } //Read the target file and verify that copy is done correctly byte[] buff = new byte[FileSize]; FileInputStream @in = new FileInputStream(outFile); try { int total = @in.Read(buff, 0, count); NUnit.Framework.Assert.AreEqual(count, total); for (int i = 0; i < count; i++) { NUnit.Framework.Assert.AreEqual(initBuff[position + i], buff[i]); } } finally { IOUtils.Cleanup(Log, @in); } //delete files and folders inFile.Delete(); outFile.Delete(); testDir.Delete(); absLogDir.Delete(); }