/// <exception cref="System.IO.IOException"/> public TestFileDescriptorPair() { fis = new FileInputStream[2]; for (int i = 0; i < 2; i++) { string name = dir.GetDir() + "/file" + i; FileOutputStream fos = new FileOutputStream(name); if (i == 0) { // write 'data' file fos.Write(1); } else { // write 'metadata' file BlockMetadataHeader header = new BlockMetadataHeader((short)1, DataChecksum.NewDataChecksum (DataChecksum.Type.Null, 4)); DataOutputStream dos = new DataOutputStream(fos); BlockMetadataHeader.WriteHeader(dos, header); dos.Close(); } fos.Close(); fis[i] = new FileInputStream(name); } }
public static void SetupCluster() { if (DomainSocket.GetLoadingFailureReason() != null) { return; } sockDir = new TemporarySocketDirectory(); HdfsConfiguration conf = new HdfsConfiguration(); conf.Set(DFSConfigKeys.DfsDomainSocketPathKey, new FilePath(sockDir.GetDir(), "TestParallelShortCircuitReadUnCached._PORT.sock" ).GetAbsolutePath()); conf.SetBoolean(DFSConfigKeys.DfsClientReadShortcircuitKey, true); // Enabling data transfer encryption should have no effect when using // short-circuit local reads. This is a regression test for HDFS-5353. conf.SetBoolean(DFSConfigKeys.DfsEncryptDataTransferKey, true); conf.SetBoolean(DFSConfigKeys.DfsBlockAccessTokenEnableKey, true); conf.SetBoolean(DFSConfigKeys.DfsClientReadShortcircuitSkipChecksumKey, false); conf.SetBoolean(DFSConfigKeys.DfsClientDomainSocketDataTraffic, true); // We want to test reading from stale sockets. conf.SetInt(DFSConfigKeys.DfsDatanodeSocketReuseKeepaliveKey, 1); conf.SetLong(DFSConfigKeys.DfsClientSocketCacheExpiryMsecKey, 5 * 60 * 1000); conf.SetInt(DFSConfigKeys.DfsClientSocketCacheCapacityKey, 32); // Avoid using the FileInputStreamCache. conf.SetInt(DFSConfigKeys.DfsClientReadShortcircuitStreamsCacheSizeKey, 0); DomainSocket.DisableBindPathValidation(); DFSInputStream.tcpReadsDisabledForTesting = true; SetupCluster(1, conf); }
/// <summary> /// If ramDiskStorageLimit is >=0, then RAM_DISK capacity is artificially /// capped. /// </summary> /// <remarks> /// If ramDiskStorageLimit is >=0, then RAM_DISK capacity is artificially /// capped. If ramDiskStorageLimit < 0 then it is ignored. /// </remarks> /// <exception cref="System.IO.IOException"/> protected internal void StartUpCluster(bool hasTransientStorage, int ramDiskReplicaCapacity , bool useSCR, bool useLegacyBlockReaderLocal) { Configuration conf = new Configuration(); conf.SetLong(DfsBlockSizeKey, BlockSize); conf.SetInt(DfsNamenodeLazyPersistFileScrubIntervalSec, LazyWriteFileScrubberIntervalSec ); conf.SetLong(DfsHeartbeatIntervalKey, HeartbeatIntervalSec); conf.SetInt(DfsNamenodeHeartbeatRecheckIntervalKey, HeartbeatRecheckIntervalMsec); conf.SetInt(DfsDatanodeLazyWriterIntervalSec, LazyWriterIntervalSec); conf.SetInt(DfsDatanodeRamDiskLowWatermarkBytes, EvictionLowWatermark * BlockSize ); if (useSCR) { conf.SetBoolean(DfsClientReadShortcircuitKey, true); // Do not share a client context across tests. conf.Set(DfsClientContext, UUID.RandomUUID().ToString()); if (useLegacyBlockReaderLocal) { conf.SetBoolean(DfsClientUseLegacyBlockreaderlocal, true); conf.Set(DfsBlockLocalPathAccessUserKey, UserGroupInformation.GetCurrentUser().GetShortUserName ()); } else { sockDir = new TemporarySocketDirectory(); conf.Set(DfsDomainSocketPathKey, new FilePath(sockDir.GetDir(), this.GetType().Name + "._PORT.sock").GetAbsolutePath()); } } long[] capacities = null; if (hasTransientStorage && ramDiskReplicaCapacity >= 0) { // Convert replica count to byte count, add some delta for .meta and // VERSION files. long ramDiskStorageLimit = ((long)ramDiskReplicaCapacity * BlockSize) + (BlockSize - 1); capacities = new long[] { ramDiskStorageLimit, -1 }; } cluster = new MiniDFSCluster.Builder(conf).NumDataNodes(ReplFactor).StorageCapacities (capacities).StorageTypes(hasTransientStorage ? new StorageType[] { StorageType. RamDisk, StorageType.Default } : null).Build(); fs = cluster.GetFileSystem(); client = fs.GetClient(); try { jmx = InitJMX(); } catch (Exception e) { NUnit.Framework.Assert.Fail("Failed initialize JMX for testing: " + e); } Log.Info("Cluster startup complete"); }
public static Configuration CreateShortCircuitConf(string testName, TemporarySocketDirectory sockDir) { Configuration conf = new Configuration(); conf.Set(DFSConfigKeys.DfsClientContext, testName); conf.SetLong(DFSConfigKeys.DfsBlockSizeKey, 4096); conf.Set(DFSConfigKeys.DfsDomainSocketPathKey, new FilePath(sockDir.GetDir(), testName + "._PORT").GetAbsolutePath()); conf.SetBoolean(DFSConfigKeys.DfsClientReadShortcircuitKey, true); conf.SetBoolean(DFSConfigKeys.DfsClientReadShortcircuitSkipChecksumKey, false); conf.SetBoolean(DFSConfigKeys.DfsClientDomainSocketDataTraffic, false); return(conf); }
private static Configuration GetDefaultConf() { HdfsConfiguration conf = new HdfsConfiguration(); conf.SetLong(DFSConfigKeys.DfsNamenodePathBasedCacheRefreshIntervalMs, 50); conf.SetLong(DFSConfigKeys.DfsCachereportIntervalMsecKey, 250); conf.SetLong(DFSConfigKeys.DfsBlockSizeKey, BlockSize); conf.SetLong(DFSConfigKeys.DfsDatanodeMaxLockedMemoryKey, TestFsDatasetCache.CacheCapacity ); conf.SetLong(DFSConfigKeys.DfsHeartbeatIntervalKey, 1); conf.SetBoolean(DFSConfigKeys.DfsClientReadShortcircuitKey, true); conf.Set(DFSConfigKeys.DfsDomainSocketPathKey, new FilePath(sockDir.GetDir(), "sock" ).GetAbsolutePath()); return(conf); }
/// <summary> /// Test that file data can be read by reading the block file /// directly from the local store. /// </summary> /// <exception cref="System.IO.IOException"/> /// <exception cref="System.Exception"/> public virtual void DoTestShortCircuitReadImpl(bool ignoreChecksum, int size, int readOffset, string shortCircuitUser, string readingUser, bool legacyShortCircuitFails ) { Configuration conf = new Configuration(); conf.SetBoolean(DFSConfigKeys.DfsClientReadShortcircuitKey, true); conf.SetBoolean(DFSConfigKeys.DfsClientReadShortcircuitSkipChecksumKey, ignoreChecksum ); // Set a random client context name so that we don't share a cache with // other invocations of this function. conf.Set(DFSConfigKeys.DfsClientContext, UUID.RandomUUID().ToString()); conf.Set(DFSConfigKeys.DfsDomainSocketPathKey, new FilePath(sockDir.GetDir(), "TestShortCircuitLocalRead._PORT.sock" ).GetAbsolutePath()); if (shortCircuitUser != null) { conf.Set(DFSConfigKeys.DfsBlockLocalPathAccessUserKey, shortCircuitUser); conf.SetBoolean(DFSConfigKeys.DfsClientUseLegacyBlockreaderlocal, true); } MiniDFSCluster cluster = new MiniDFSCluster.Builder(conf).NumDataNodes(1).Format( true).Build(); FileSystem fs = cluster.GetFileSystem(); try { // check that / exists Path path = new Path("/"); NUnit.Framework.Assert.IsTrue("/ should be a directory", fs.GetFileStatus(path).IsDirectory () == true); byte[] fileData = AppendTestUtil.RandomBytes(seed, size); Path file1 = fs.MakeQualified(new Path("filelocal.dat")); FSDataOutputStream stm = CreateFile(fs, file1, 1); stm.Write(fileData); stm.Close(); URI uri = cluster.GetURI(); CheckFileContent(uri, file1, fileData, readOffset, readingUser, conf, legacyShortCircuitFails ); CheckFileContentDirect(uri, file1, fileData, readOffset, readingUser, conf, legacyShortCircuitFails ); } finally { fs.Close(); cluster.Shutdown(); } }
public static void SetupCluster() { if (DomainSocket.GetLoadingFailureReason() != null) { return; } DFSInputStream.tcpReadsDisabledForTesting = true; sockDir = new TemporarySocketDirectory(); HdfsConfiguration conf = new HdfsConfiguration(); conf.Set(DFSConfigKeys.DfsDomainSocketPathKey, new FilePath(sockDir.GetDir(), "TestParallelLocalRead.%d.sock" ).GetAbsolutePath()); conf.SetBoolean(DFSConfigKeys.DfsClientReadShortcircuitKey, true); conf.SetBoolean(DFSConfigKeys.DfsClientReadShortcircuitSkipChecksumKey, false); DomainSocket.DisableBindPathValidation(); SetupCluster(1, conf); }
private static Configuration CreateShortCircuitConf(string testName, TemporarySocketDirectory sockDir) { Configuration conf = new Configuration(); conf.Set(DFSConfigKeys.DfsClientContext, testName); conf.SetLong(DFSConfigKeys.DfsBlockSizeKey, 4096); conf.Set(DFSConfigKeys.DfsDomainSocketPathKey, new FilePath(sockDir.GetDir(), testName ).GetAbsolutePath()); conf.SetBoolean(DFSConfigKeys.DfsClientReadShortcircuitKey, true); conf.SetBoolean(DFSConfigKeys.DfsClientReadShortcircuitSkipChecksumKey, false); conf.SetBoolean(DFSConfigKeys.DfsClientDomainSocketDataTraffic, false); DFSInputStream.tcpReadsDisabledForTesting = true; DomainSocket.DisableBindPathValidation(); Assume.AssumeThat(DomainSocket.GetLoadingFailureReason(), CoreMatchers.EqualTo(null )); return(conf); }
public static HdfsConfiguration InitZeroCopyTest() { Assume.AssumeTrue(NativeIO.IsAvailable()); Assume.AssumeTrue(SystemUtils.IsOsUnix); HdfsConfiguration conf = new HdfsConfiguration(); conf.SetBoolean(DFSConfigKeys.DfsClientReadShortcircuitKey, true); conf.SetLong(DFSConfigKeys.DfsBlockSizeKey, BlockSize); conf.SetInt(DFSConfigKeys.DfsClientMmapCacheSize, 3); conf.SetLong(DFSConfigKeys.DfsClientMmapCacheTimeoutMs, 100); conf.Set(DFSConfigKeys.DfsDomainSocketPathKey, new FilePath(sockDir.GetDir(), "TestRequestMmapAccess._PORT.sock" ).GetAbsolutePath()); conf.SetBoolean(DFSConfigKeys.DfsClientReadShortcircuitSkipChecksumKey, true); conf.SetLong(DFSConfigKeys.DfsHeartbeatIntervalKey, 1); conf.SetLong(DFSConfigKeys.DfsCachereportIntervalMsecKey, 1000); conf.SetLong(DFSConfigKeys.DfsNamenodePathBasedCacheRefreshIntervalMs, 1000); return(conf); }
public virtual void TestCreateAndDestroySpanReceiver() { Configuration conf = new Configuration(); conf = new Configuration(); conf.Set(DFSConfigKeys.DfsServerHtracePrefix + SpanReceiverHost.SpanReceiversConfSuffix , string.Empty); MiniDFSCluster cluster = new MiniDFSCluster.Builder(conf).NumDataNodes(3).Build(); cluster.WaitActive(); TemporarySocketDirectory tempDir = new TemporarySocketDirectory(); string tracePath = new FilePath(tempDir.GetDir(), "tracefile").GetAbsolutePath(); try { TraceAdmin trace = new TraceAdmin(); trace.SetConf(conf); NUnit.Framework.Assert.AreEqual("ret:0, [no span receivers found]" + Newline, RunTraceCommand (trace, "-list", "-host", GetHostPortForNN(cluster))); NUnit.Framework.Assert.AreEqual("ret:0, Added trace span receiver 1 with " + "configuration local-file-span-receiver.path = " + tracePath + Newline, RunTraceCommand(trace, "-add", "-host", GetHostPortForNN (cluster), "-class", "org.apache.htrace.impl.LocalFileSpanReceiver", "-Clocal-file-span-receiver.path=" + tracePath)); string list = RunTraceCommand(trace, "-list", "-host", GetHostPortForNN(cluster)); NUnit.Framework.Assert.IsTrue(list.StartsWith("ret:0")); NUnit.Framework.Assert.IsTrue(list.Contains("1 org.apache.htrace.impl.LocalFileSpanReceiver" )); NUnit.Framework.Assert.AreEqual("ret:0, Removed trace span receiver 1" + Newline, RunTraceCommand(trace, "-remove", "1", "-host", GetHostPortForNN(cluster))); NUnit.Framework.Assert.AreEqual("ret:0, [no span receivers found]" + Newline, RunTraceCommand (trace, "-list", "-host", GetHostPortForNN(cluster))); NUnit.Framework.Assert.AreEqual("ret:0, Added trace span receiver 2 with " + "configuration local-file-span-receiver.path = " + tracePath + Newline, RunTraceCommand(trace, "-add", "-host", GetHostPortForNN (cluster), "-class", "LocalFileSpanReceiver", "-Clocal-file-span-receiver.path=" + tracePath)); NUnit.Framework.Assert.AreEqual("ret:0, Removed trace span receiver 2" + Newline, RunTraceCommand(trace, "-remove", "2", "-host", GetHostPortForNN(cluster))); } finally { cluster.Shutdown(); tempDir.Close(); } }
/// <summary> /// If ramDiskStorageLimit is >=0, then RAM_DISK capacity is artificially /// capped. /// </summary> /// <remarks> /// If ramDiskStorageLimit is >=0, then RAM_DISK capacity is artificially /// capped. If ramDiskStorageLimit < 0 then it is ignored. /// </remarks> /// <exception cref="System.IO.IOException"/> protected internal void StartUpCluster(int numDataNodes, StorageType[] storageTypes , long ramDiskStorageLimit, bool useSCR) { Configuration conf = new Configuration(); conf.SetLong(DfsBlockSizeKey, BlockSize); conf.SetInt(DfsNamenodeLazyPersistFileScrubIntervalSec, LazyWriteFileScrubberIntervalSec ); conf.SetLong(DfsHeartbeatIntervalKey, HeartbeatIntervalSec); conf.SetInt(DfsNamenodeHeartbeatRecheckIntervalKey, HeartbeatRecheckIntervalMsec); conf.SetInt(DfsDatanodeLazyWriterIntervalSec, LazyWriterIntervalSec); if (useSCR) { conf.SetBoolean(DfsClientReadShortcircuitKey, useSCR); conf.Set(DfsClientContext, UUID.RandomUUID().ToString()); sockDir = new TemporarySocketDirectory(); conf.Set(DfsDomainSocketPathKey, new FilePath(sockDir.GetDir(), this.GetType().Name + "._PORT.sock").GetAbsolutePath()); conf.Set(DfsBlockLocalPathAccessUserKey, UserGroupInformation.GetCurrentUser().GetShortUserName ()); } cluster = new MiniDFSCluster.Builder(conf).NumDataNodes(numDataNodes).StorageTypes (storageTypes != null ? storageTypes : new StorageType[] { StorageType.Default, StorageType.Default }).Build(); fs = cluster.GetFileSystem(); client = fs.GetClient(); // Artificially cap the storage capacity of the RAM_DISK volume. if (ramDiskStorageLimit >= 0) { IList <FsVolumeSpi> volumes = cluster.GetDataNodes()[0].GetFSDataset().GetVolumes( ); foreach (FsVolumeSpi volume in volumes) { if (volume.GetStorageType() == StorageType.RamDisk) { ((FsVolumeImpl)volume).SetCapacityForTesting(ramDiskStorageLimit); } } } Log.Info("Cluster startup complete"); }
/// <exception cref="System.IO.IOException"/> private static HdfsConfiguration GetConfiguration(TemporarySocketDirectory socketDir ) { HdfsConfiguration conf = new HdfsConfiguration(); if (socketDir == null) { conf.Set(DFSConfigKeys.DfsDomainSocketPathKey, string.Empty); } else { conf.Set(DFSConfigKeys.DfsDomainSocketPathKey, new FilePath(socketDir.GetDir(), "TestBlockReaderLocalLegacy.%d.sock" ).GetAbsolutePath()); } conf.SetBoolean(DFSConfigKeys.DfsClientReadShortcircuitKey, true); conf.SetBoolean(DFSConfigKeys.DfsClientUseLegacyBlockreaderlocal, true); conf.SetBoolean(DFSConfigKeys.DfsClientReadShortcircuitSkipChecksumKey, false); conf.Set(DFSConfigKeys.DfsBlockLocalPathAccessUserKey, UserGroupInformation.GetCurrentUser ().GetShortUserName()); conf.SetBoolean(DFSConfigKeys.DfsClientDomainSocketDataTraffic, false); // Set short retry timeouts so this test runs faster conf.SetInt(DFSConfigKeys.DfsClientRetryWindowBase, 10); return(conf); }
/// <exception cref="System.Exception"/> private void TestStatistics(bool isShortCircuit) { Assume.AssumeTrue(DomainSocket.GetLoadingFailureReason() == null); HdfsConfiguration conf = new HdfsConfiguration(); TemporarySocketDirectory sockDir = null; if (isShortCircuit) { DFSInputStream.tcpReadsDisabledForTesting = true; sockDir = new TemporarySocketDirectory(); conf.Set(DFSConfigKeys.DfsDomainSocketPathKey, new FilePath(sockDir.GetDir(), "TestStatisticsForLocalRead.%d.sock" ).GetAbsolutePath()); conf.SetBoolean(DFSConfigKeys.DfsClientReadShortcircuitKey, true); DomainSocket.DisableBindPathValidation(); } else { conf.SetBoolean(DFSConfigKeys.DfsClientReadShortcircuitKey, false); } MiniDFSCluster cluster = null; Path TestPath = new Path("/a"); long RandomSeed = 4567L; FSDataInputStream fsIn = null; byte[] original = new byte[TestBlockReaderLocal.BlockReaderLocalTest.TestLength]; FileSystem fs = null; try { cluster = new MiniDFSCluster.Builder(conf).NumDataNodes(1).Build(); cluster.WaitActive(); fs = cluster.GetFileSystem(); DFSTestUtil.CreateFile(fs, TestPath, TestBlockReaderLocal.BlockReaderLocalTest.TestLength , (short)1, RandomSeed); try { DFSTestUtil.WaitReplication(fs, TestPath, (short)1); } catch (Exception e) { NUnit.Framework.Assert.Fail("unexpected InterruptedException during " + "waitReplication: " + e); } catch (TimeoutException e) { NUnit.Framework.Assert.Fail("unexpected TimeoutException during " + "waitReplication: " + e); } fsIn = fs.Open(TestPath); IOUtils.ReadFully(fsIn, original, 0, TestBlockReaderLocal.BlockReaderLocalTest.TestLength ); HdfsDataInputStream dfsIn = (HdfsDataInputStream)fsIn; NUnit.Framework.Assert.AreEqual(TestBlockReaderLocal.BlockReaderLocalTest.TestLength , dfsIn.GetReadStatistics().GetTotalBytesRead()); NUnit.Framework.Assert.AreEqual(TestBlockReaderLocal.BlockReaderLocalTest.TestLength , dfsIn.GetReadStatistics().GetTotalLocalBytesRead()); if (isShortCircuit) { NUnit.Framework.Assert.AreEqual(TestBlockReaderLocal.BlockReaderLocalTest.TestLength , dfsIn.GetReadStatistics().GetTotalShortCircuitBytesRead()); } else { NUnit.Framework.Assert.AreEqual(0, dfsIn.GetReadStatistics().GetTotalShortCircuitBytesRead ()); } fsIn.Close(); fsIn = null; } finally { DFSInputStream.tcpReadsDisabledForTesting = false; if (fsIn != null) { fsIn.Close(); } if (fs != null) { fs.Close(); } if (cluster != null) { cluster.Shutdown(); } if (sockDir != null) { sockDir.Close(); } } }
/// <exception cref="System.IO.IOException"/> public virtual void RunBlockReaderLocalTest(TestBlockReaderLocal.BlockReaderLocalTest test, bool checksum, long readahead) { Assume.AssumeThat(DomainSocket.GetLoadingFailureReason(), CoreMatchers.EqualTo(null )); MiniDFSCluster cluster = null; HdfsConfiguration conf = new HdfsConfiguration(); conf.SetBoolean(DFSConfigKeys.DfsClientReadShortcircuitSkipChecksumKey, !checksum ); conf.SetLong(DFSConfigKeys.DfsBytesPerChecksumKey, TestBlockReaderLocal.BlockReaderLocalTest .BytesPerChecksum); conf.Set(DFSConfigKeys.DfsChecksumTypeKey, "CRC32C"); conf.SetLong(DFSConfigKeys.DfsClientCacheReadahead, readahead); test.SetConfiguration(conf); FileInputStream dataIn = null; FileInputStream metaIn = null; Path TestPath = new Path("/a"); long RandomSeed = 4567L; BlockReaderLocal blockReaderLocal = null; FSDataInputStream fsIn = null; byte[] original = new byte[TestBlockReaderLocal.BlockReaderLocalTest.TestLength]; FileSystem fs = null; ShortCircuitShm shm = null; RandomAccessFile raf = null; try { cluster = new MiniDFSCluster.Builder(conf).NumDataNodes(1).Build(); cluster.WaitActive(); fs = cluster.GetFileSystem(); DFSTestUtil.CreateFile(fs, TestPath, TestBlockReaderLocal.BlockReaderLocalTest.TestLength , (short)1, RandomSeed); try { DFSTestUtil.WaitReplication(fs, TestPath, (short)1); } catch (Exception e) { NUnit.Framework.Assert.Fail("unexpected InterruptedException during " + "waitReplication: " + e); } catch (TimeoutException e) { NUnit.Framework.Assert.Fail("unexpected TimeoutException during " + "waitReplication: " + e); } fsIn = fs.Open(TestPath); IOUtils.ReadFully(fsIn, original, 0, TestBlockReaderLocal.BlockReaderLocalTest.TestLength ); fsIn.Close(); fsIn = null; ExtendedBlock block = DFSTestUtil.GetFirstBlock(fs, TestPath); FilePath dataFile = cluster.GetBlockFile(0, block); FilePath metaFile = cluster.GetBlockMetadataFile(0, block); ShortCircuitCache shortCircuitCache = ClientContext.GetFromConf(conf).GetShortCircuitCache (); cluster.Shutdown(); cluster = null; test.Setup(dataFile, checksum); FileInputStream[] streams = new FileInputStream[] { new FileInputStream(dataFile) , new FileInputStream(metaFile) }; dataIn = streams[0]; metaIn = streams[1]; ExtendedBlockId key = new ExtendedBlockId(block.GetBlockId(), block.GetBlockPoolId ()); raf = new RandomAccessFile(new FilePath(sockDir.GetDir().GetAbsolutePath(), UUID. RandomUUID().ToString()), "rw"); raf.SetLength(8192); FileInputStream shmStream = new FileInputStream(raf.GetFD()); shm = new ShortCircuitShm(ShortCircuitShm.ShmId.CreateRandom(), shmStream); ShortCircuitReplica replica = new ShortCircuitReplica(key, dataIn, metaIn, shortCircuitCache , Time.Now(), shm.AllocAndRegisterSlot(ExtendedBlockId.FromExtendedBlock(block)) ); blockReaderLocal = new BlockReaderLocal.Builder(new DFSClient.Conf(conf)).SetFilename (TestPath.GetName()).SetBlock(block).SetShortCircuitReplica(replica).SetCachingStrategy (new CachingStrategy(false, readahead)).SetVerifyChecksum(checksum).Build(); dataIn = null; metaIn = null; test.DoTest(blockReaderLocal, original); // BlockReaderLocal should not alter the file position. NUnit.Framework.Assert.AreEqual(0, streams[0].GetChannel().Position()); NUnit.Framework.Assert.AreEqual(0, streams[1].GetChannel().Position()); } finally { if (fsIn != null) { fsIn.Close(); } if (fs != null) { fs.Close(); } if (cluster != null) { cluster.Shutdown(); } if (dataIn != null) { dataIn.Close(); } if (metaIn != null) { metaIn.Close(); } if (blockReaderLocal != null) { blockReaderLocal.Close(); } if (shm != null) { shm.Free(); } if (raf != null) { raf.Close(); } } }