public virtual void TestFailedDirLogDeletion() { FilePath[] localLogDirs = GetLocalLogDirFiles(this.GetType().FullName, 7); IList <string> localLogDirPaths = new AList <string>(localLogDirs.Length); for (int i = 0; i < localLogDirs.Length; i++) { localLogDirPaths.AddItem(localLogDirs[i].GetAbsolutePath()); } string localLogDirsString = StringUtils.Join(localLogDirPaths, ","); conf.Set(YarnConfiguration.NmLogDirs, localLogDirsString); conf.SetBoolean(YarnConfiguration.LogAggregationEnabled, false); conf.SetLong(YarnConfiguration.NmLogRetainSeconds, 0l); LocalDirsHandlerService mockDirsHandler = Org.Mockito.Mockito.Mock <LocalDirsHandlerService >(); NonAggregatingLogHandler rawLogHandler = new NonAggregatingLogHandler(dispatcher, mockDelService, mockDirsHandler, new NMNullStateStoreService()); NonAggregatingLogHandler logHandler = Org.Mockito.Mockito.Spy(rawLogHandler); AbstractFileSystem spylfs = Org.Mockito.Mockito.Spy(FileContext.GetLocalFSFileContext ().GetDefaultFileSystem()); FileContext lfs = FileContext.GetFileContext(spylfs, conf); Org.Mockito.Mockito.DoReturn(lfs).When(logHandler).GetLocalFileContext(Matchers.IsA <Configuration>()); logHandler.Init(conf); logHandler.Start(); RunMockedFailedDirs(logHandler, appId, user, mockDelService, mockDirsHandler, conf , spylfs, lfs, localLogDirs); logHandler.Close(); }
public virtual void TestContainerLocalizerClosesFilesystems() { // mocked generics // verify filesystems are closed when localizer doesn't fail FileContext fs = FileContext.GetLocalFSFileContext(); spylfs = Org.Mockito.Mockito.Spy(fs.GetDefaultFileSystem()); ContainerLocalizer localizer = SetupContainerLocalizerForTest(); Org.Mockito.Mockito.DoNothing().When(localizer).LocalizeFiles(Matchers.Any <LocalizationProtocol >(), Matchers.Any <CompletionService>(), Matchers.Any <UserGroupInformation>()); Org.Mockito.Mockito.Verify(localizer, Org.Mockito.Mockito.Never()).CloseFileSystems (Matchers.Any <UserGroupInformation>()); localizer.RunLocalization(nmAddr); Org.Mockito.Mockito.Verify(localizer).CloseFileSystems(Matchers.Any <UserGroupInformation >()); spylfs = Org.Mockito.Mockito.Spy(fs.GetDefaultFileSystem()); // verify filesystems are closed when localizer fails localizer = SetupContainerLocalizerForTest(); Org.Mockito.Mockito.DoThrow(new YarnRuntimeException("Forced Failure")).When(localizer ).LocalizeFiles(Matchers.Any <LocalizationProtocol>(), Matchers.Any <CompletionService >(), Matchers.Any <UserGroupInformation>()); Org.Mockito.Mockito.Verify(localizer, Org.Mockito.Mockito.Never()).CloseFileSystems (Matchers.Any <UserGroupInformation>()); localizer.RunLocalization(nmAddr); Org.Mockito.Mockito.Verify(localizer).CloseFileSystems(Matchers.Any <UserGroupInformation >()); }
/// <summary> /// Load the KeyPair from the file, or generate a new one. /// </summary> /// <param name="fileSystem">FileSystem implementation</param> public void Load(AbstractFileSystem fileSystem) { var exists = fileSystem.FileExists(_path); if (exists) { var data = fileSystem.ReadFileAsString(_path); if (data != null) { var split = data.Split(' '); if (split.Length != 2) { throw new FormatException("Keys file doesn't contain proper data."); } var ecp = GetParams(); var q = Convert.FromBase64String(split[1]); var point = ecp.Curve.DecodePoint(q); var pubParams = new ECPublicKeyParameters(point, ecp); var d = new BigInteger(Convert.FromBase64String(split[0])); var privParams = new ECPrivateKeyParameters(d, ecp); BcKeyPair = new AsymmetricCipherKeyPair(pubParams, privParams); } } else { var key = Generate(); Save(fileSystem, key); BcKeyPair = key; } }
/// <summary> /// Save the specified KeyPair. /// </summary> /// <param name="fileSystem">FileSystem implementation</param> /// <param name="keyPair">BouncyCastle Asymmetric KeyPair</param> private void Save(AbstractFileSystem fileSystem, AsymmetricCipherKeyPair keyPair) { var privateBytes = ((ECPrivateKeyParameters)keyPair.Private).D.ToByteArray(); var publicBytes = ((ECPublicKeyParameters)keyPair.Public).Q.GetEncoded(); var data = Convert.ToBase64String(privateBytes) + " " + Convert.ToBase64String(publicBytes); fileSystem.WriteFileFromString(_path, data); }
/// <exception cref="Org.Apache.Hadoop.FS.UnsupportedFileSystemException"/> private void TestDefaultUriInternal(string defaultUri) { Configuration conf = new Configuration(); FileSystem.SetDefaultUri(conf, defaultUri); AbstractFileSystem ftpFs = AbstractFileSystem.Get(FtpUriNoPort, conf); Assert.Equal(FtpUriWithPort, ftpFs.GetUri()); }
/// <summary> /// Function to run a log handler with directories failing the getFileStatus /// call. /// </summary> /// <remarks> /// Function to run a log handler with directories failing the getFileStatus /// call. The function accepts the log handler, setup the mocks to fail with /// specific exceptions and ensures the deletion service has the correct calls. /// </remarks> /// <param name="logHandler">the logHandler implementation to test</param> /// <param name="appId"> /// the application id that we wish when sending events to the log /// handler /// </param> /// <param name="user">the user name to use</param> /// <param name="mockDelService"> /// a mock of the DeletionService which we will verify /// the delete calls against /// </param> /// <param name="dirsHandler"> /// a spy or mock on the LocalDirsHandler service used to /// when creating the logHandler. It needs to be a spy so that we can intercept /// the getAllLogDirs() call. /// </param> /// <param name="conf">the configuration used</param> /// <param name="spylfs">a spy on the AbstractFileSystem object used when creating lfs /// </param> /// <param name="lfs"> /// the FileContext object to be used to mock the getFileStatus() /// calls /// </param> /// <param name="localLogDirs"> /// list of the log dirs to run the test against, must have /// at least 7 entries /// </param> /// <exception cref="System.Exception"/> public static void RunMockedFailedDirs(LogHandler logHandler, ApplicationId appId , string user, DeletionService mockDelService, LocalDirsHandlerService dirsHandler , Configuration conf, AbstractFileSystem spylfs, FileContext lfs, FilePath[] localLogDirs ) { IDictionary <ApplicationAccessType, string> appAcls = new Dictionary <ApplicationAccessType , string>(); if (localLogDirs.Length < 7) { throw new ArgumentException("Argument localLogDirs must be at least of length 7"); } Path[] localAppLogDirPaths = new Path[localLogDirs.Length]; for (int i = 0; i < localAppLogDirPaths.Length; i++) { localAppLogDirPaths[i] = new Path(localLogDirs[i].GetAbsolutePath(), appId.ToString ()); } IList <string> localLogDirPaths = new AList <string>(localLogDirs.Length); for (int i_1 = 0; i_1 < localLogDirs.Length; i_1++) { localLogDirPaths.AddItem(localLogDirs[i_1].GetAbsolutePath()); } // setup mocks FsPermission defaultPermission = FsPermission.GetDirDefault().ApplyUMask(lfs.GetUMask ()); FileStatus fs = new FileStatus(0, true, 1, 0, Runtime.CurrentTimeMillis(), 0, defaultPermission , string.Empty, string.Empty, new Path(localLogDirs[0].GetAbsolutePath())); Org.Mockito.Mockito.DoReturn(fs).When(spylfs).GetFileStatus(Matchers.IsA <Path>()); Org.Mockito.Mockito.DoReturn(localLogDirPaths).When(dirsHandler).GetLogDirsForCleanup (); logHandler.Handle(new LogHandlerAppStartedEvent(appId, user, null, ContainerLogsRetentionPolicy .AllContainers, appAcls)); // test case where some dirs have the log dir to delete // mock some dirs throwing various exceptions // verify deletion happens only on the others Org.Mockito.Mockito.DoThrow(new FileNotFoundException()).When(spylfs).GetFileStatus (Matchers.Eq(localAppLogDirPaths[0])); Org.Mockito.Mockito.DoReturn(fs).When(spylfs).GetFileStatus(Matchers.Eq(localAppLogDirPaths [1])); Org.Mockito.Mockito.DoThrow(new AccessControlException()).When(spylfs).GetFileStatus (Matchers.Eq(localAppLogDirPaths[2])); Org.Mockito.Mockito.DoReturn(fs).When(spylfs).GetFileStatus(Matchers.Eq(localAppLogDirPaths [3])); Org.Mockito.Mockito.DoThrow(new IOException()).When(spylfs).GetFileStatus(Matchers.Eq (localAppLogDirPaths[4])); Org.Mockito.Mockito.DoThrow(new UnsupportedFileSystemException("test")).When(spylfs ).GetFileStatus(Matchers.Eq(localAppLogDirPaths[5])); Org.Mockito.Mockito.DoReturn(fs).When(spylfs).GetFileStatus(Matchers.Eq(localAppLogDirPaths [6])); logHandler.Handle(new LogHandlerAppFinishedEvent(appId)); TestDeletionServiceCall(mockDelService, user, 5000, localAppLogDirPaths[1], localAppLogDirPaths [3], localAppLogDirPaths[6]); return; }
public virtual void TestIsValidNameInvalidInBaseFs() { AbstractFileSystem baseFs = Org.Mockito.Mockito.Spy(fc.GetDefaultFileSystem()); ChRootedFs chRootedFs = new ChRootedFs(baseFs, new Path("/chroot")); Org.Mockito.Mockito.DoReturn(false).When(baseFs).IsValidName(Org.Mockito.Mockito. AnyString()); NUnit.Framework.Assert.IsFalse(chRootedFs.IsValidName("/test")); Org.Mockito.Mockito.Verify(baseFs).IsValidName("/chroot/test"); }
public virtual void TestFcDelegationToken() { FileContext fcHdfs = FileContext.GetFileContext(cluster.GetFileSystem().GetUri()); AbstractFileSystem afs = fcHdfs.GetDefaultFileSystem(); IList <Org.Apache.Hadoop.Security.Token.Token <object> > tokenList = afs.GetDelegationTokens (UserGroupInformation.GetCurrentUser().GetUserName()); ((Org.Apache.Hadoop.FS.Hdfs)afs).RenewDelegationToken((Org.Apache.Hadoop.Security.Token.Token <DelegationTokenIdentifier>)tokenList[0]); ((Org.Apache.Hadoop.FS.Hdfs)afs).CancelDelegationToken((Org.Apache.Hadoop.Security.Token.Token <AbstractDelegationTokenIdentifier>)tokenList[0]); }
public virtual void TestLocalizerTokenIsGettingRemoved() { FileContext fs = FileContext.GetLocalFSFileContext(); spylfs = Org.Mockito.Mockito.Spy(fs.GetDefaultFileSystem()); ContainerLocalizer localizer = SetupContainerLocalizerForTest(); Org.Mockito.Mockito.DoNothing().When(localizer).LocalizeFiles(Matchers.Any <LocalizationProtocol >(), Matchers.Any <CompletionService>(), Matchers.Any <UserGroupInformation>()); localizer.RunLocalization(nmAddr); Org.Mockito.Mockito.Verify(spylfs, Org.Mockito.Mockito.Times(1)).Delete(tokenPath , false); }
/// <exception cref="System.Exception"/> public virtual void TestHdfsGetCanonicalServiceName() { Configuration conf = dfs.GetConf(); URI haUri = HATestUtil.GetLogicalUri(cluster); AbstractFileSystem afs = AbstractFileSystem.CreateFileSystem(haUri, conf); string haService = HAUtil.BuildTokenServiceForLogicalUri(haUri, HdfsConstants.HdfsUriScheme ).ToString(); NUnit.Framework.Assert.AreEqual(haService, afs.GetCanonicalServiceName()); Org.Apache.Hadoop.Security.Token.Token <object> token = afs.GetDelegationTokens(UserGroupInformation .GetCurrentUser().GetShortUserName())[0]; NUnit.Framework.Assert.AreEqual(haService, token.GetService().ToString()); // make sure the logical uri is handled correctly token.Renew(conf); token.Cancel(conf); }
/// <exception cref="System.IO.IOException"/> public virtual void TestAccessLinkFromAbstractFileSystem() { Path file = new Path(TestBaseDir1(), "file"); Path link = new Path(TestBaseDir1(), "linkToFile"); CreateAndWriteFile(file); wrapper.CreateSymlink(file, link, false); try { AbstractFileSystem afs = fc.GetDefaultFileSystem(); afs.Open(link); NUnit.Framework.Assert.Fail("Opened a link using AFS"); } catch (UnresolvedLinkException) { } }
public virtual void TestGetFileChecksum() { AbstractFileSystem mockAFS = Org.Mockito.Mockito.Mock <AbstractFileSystem>(); InodeTree.ResolveResult <AbstractFileSystem> res = new InodeTree.ResolveResult <AbstractFileSystem >(null, mockAFS, null, new Path("someFile")); InodeTree <AbstractFileSystem> fsState = Org.Mockito.Mockito.Mock <InodeTree>(); Org.Mockito.Mockito.When(fsState.Resolve(Org.Mockito.Mockito.AnyString(), Org.Mockito.Mockito .AnyBoolean())).ThenReturn(res); ViewFs vfs = Org.Mockito.Mockito.Mock <ViewFs>(); vfs.fsState = fsState; Org.Mockito.Mockito.When(vfs.GetFileChecksum(new Path("/tmp/someFile"))).ThenCallRealMethod (); vfs.GetFileChecksum(new Path("/tmp/someFile")); Org.Mockito.Mockito.Verify(mockAFS).GetFileChecksum(new Path("someFile")); }
public virtual void TestLogDeletion() { FilePath[] localLogDirs = GetLocalLogDirFiles(this.GetType().FullName, 2); string localLogDirsString = localLogDirs[0].GetAbsolutePath() + "," + localLogDirs [1].GetAbsolutePath(); conf.Set(YarnConfiguration.NmLogDirs, localLogDirsString); conf.SetBoolean(YarnConfiguration.LogAggregationEnabled, false); conf.SetLong(YarnConfiguration.NmLogRetainSeconds, 0l); dirsHandler.Init(conf); NonAggregatingLogHandler rawLogHandler = new NonAggregatingLogHandler(dispatcher, mockDelService, dirsHandler, new NMNullStateStoreService()); NonAggregatingLogHandler logHandler = Org.Mockito.Mockito.Spy(rawLogHandler); AbstractFileSystem spylfs = Org.Mockito.Mockito.Spy(FileContext.GetLocalFSFileContext ().GetDefaultFileSystem()); FileContext lfs = FileContext.GetFileContext(spylfs, conf); Org.Mockito.Mockito.DoReturn(lfs).When(logHandler).GetLocalFileContext(Matchers.IsA <Configuration>()); FsPermission defaultPermission = FsPermission.GetDirDefault().ApplyUMask(lfs.GetUMask ()); FileStatus fs = new FileStatus(0, true, 1, 0, Runtime.CurrentTimeMillis(), 0, defaultPermission , string.Empty, string.Empty, new Path(localLogDirs[0].GetAbsolutePath())); Org.Mockito.Mockito.DoReturn(fs).When(spylfs).GetFileStatus(Matchers.IsA <Path>()); logHandler.Init(conf); logHandler.Start(); logHandler.Handle(new LogHandlerAppStartedEvent(appId, user, null, ContainerLogsRetentionPolicy .AllContainers, null)); logHandler.Handle(new LogHandlerContainerFinishedEvent(container11, 0)); logHandler.Handle(new LogHandlerAppFinishedEvent(appId)); Path[] localAppLogDirs = new Path[2]; localAppLogDirs[0] = new Path(localLogDirs[0].GetAbsolutePath(), appId.ToString() ); localAppLogDirs[1] = new Path(localLogDirs[1].GetAbsolutePath(), appId.ToString() ); TestDeletionServiceCall(mockDelService, user, 5000, localAppLogDirs); logHandler.Close(); for (int i = 0; i < localLogDirs.Length; i++) { FileUtils.DeleteDirectory(localLogDirs[i]); } }
/// <summary> /// Performs the operation specified by the next function, calling it /// repeatedly until all symlinks in the given path are resolved. /// </summary> /// <param name="fc">FileContext used to access file systems.</param> /// <param name="path">The path to resolve symlinks on.</param> /// <returns>Generic type determined by the implementation of next.</returns> /// <exception cref="System.IO.IOException"/> public virtual T Resolve(FileContext fc, Path path) { int count = 0; T @in = null; Path p = path; // NB: More than one AbstractFileSystem can match a scheme, eg // "file" resolves to LocalFs but could have come by RawLocalFs. AbstractFileSystem fs = fc.GetFSofPath(p); // Loop until all symlinks are resolved or the limit is reached for (bool isLink = true; isLink;) { try { @in = Next(fs, p); isLink = false; } catch (UnresolvedLinkException e) { if (!fc.resolveSymlinks) { throw new IOException("Path " + path + " contains a symlink" + " and symlink resolution is disabled (" + CommonConfigurationKeys.FsClientResolveRemoteSymlinksKey + ").", e); } if (!FileSystem.AreSymlinksEnabled()) { throw new IOException("Symlink resolution is disabled in" + " this version of Hadoop." ); } if (count++ > FsConstants.MaxPathLinks) { throw new IOException("Possible cyclic loop while " + "following symbolic link " + path); } // Resolve the first unresolved path component p = QualifySymlinkTarget(fs.GetUri(), p, fs.GetLinkTarget(p)); fs = fc.GetFSofPath(p); } } return(@in); }
/// <exception cref="URISyntaxException"/> public ChRootedFs(AbstractFileSystem fs, Path theRoot) : base(fs.GetUri(), fs.GetUri().GetScheme(), fs.GetUri().GetAuthority() != null, fs.GetUriDefaultPort()) { myFs = fs; myFs.CheckPath(theRoot); chRootPathPart = new Path(myFs.GetUriPath(theRoot)); chRootPathPartString = chRootPathPart.ToUri().GetPath(); /* * We are making URI include the chrootedPath: e.g. file:///chrootedPath. * This is questionable since Path#makeQualified(uri, path) ignores * the pathPart of a uri. Since this class is internal we can ignore * this issue but if we were to make it external then this needs * to be resolved. */ // Handle the two cases: // scheme:/// and scheme://authority/ myUri = new URI(myFs.GetUri().ToString() + (myFs.GetUri().GetAuthority() == null ? string.Empty : Path.Separator) + Runtime.Substring(chRootPathPart.ToUri( ).GetPath(), 1)); base.CheckPath(theRoot); }
/// <summary> /// Generic helper function overridden on instantiation to perform a /// specific operation on the given file system using the given path /// which may result in an UnresolvedLinkException. /// </summary> /// <param name="fs">AbstractFileSystem to perform the operation on.</param> /// <param name="p">Path given the file system.</param> /// <returns>Generic type determined by the specific implementation.</returns> /// <exception cref="UnresolvedLinkException"> /// If symbolic link <code>path</code> could /// not be resolved /// </exception> /// <exception cref="System.IO.IOException">an I/O error occurred</exception> /// <exception cref="Org.Apache.Hadoop.FS.UnresolvedLinkException"/> public abstract T Next(AbstractFileSystem fs, Path p);
protected AbstractPlatform(AbstractFileSystem fileSystem = null) { FileSystem = fileSystem; }
/// <exception cref="URISyntaxException"/> protected internal FilterFs(AbstractFileSystem fs) : base(fs.GetUri(), fs.GetUri().GetScheme(), fs.GetUri().GetAuthority() != null, fs.GetUriDefaultPort()) { myFs = fs; }
public virtual void TestContainerLocalizerMain() { FileContext fs = FileContext.GetLocalFSFileContext(); spylfs = Org.Mockito.Mockito.Spy(fs.GetDefaultFileSystem()); ContainerLocalizer localizer = SetupContainerLocalizerForTest(); // verify created cache IList <Path> privCacheList = new AList <Path>(); IList <Path> appCacheList = new AList <Path>(); foreach (Path p in localDirs) { Path @base = new Path(new Path(p, ContainerLocalizer.Usercache), appUser); Path privcache = new Path(@base, ContainerLocalizer.Filecache); privCacheList.AddItem(privcache); Path appDir = new Path(@base, new Path(ContainerLocalizer.Appcache, appId)); Path appcache = new Path(appDir, ContainerLocalizer.Filecache); appCacheList.AddItem(appcache); } // mock heartbeat responses from NM ResourceLocalizationSpec rsrcA = GetMockRsrc(random, LocalResourceVisibility.Private , privCacheList[0]); ResourceLocalizationSpec rsrcB = GetMockRsrc(random, LocalResourceVisibility.Private , privCacheList[0]); ResourceLocalizationSpec rsrcC = GetMockRsrc(random, LocalResourceVisibility.Application , appCacheList[0]); ResourceLocalizationSpec rsrcD = GetMockRsrc(random, LocalResourceVisibility.Private , privCacheList[0]); Org.Mockito.Mockito.When(nmProxy.Heartbeat(Matchers.IsA <LocalizerStatus>())).ThenReturn (new MockLocalizerHeartbeatResponse(LocalizerAction.Live, Sharpen.Collections.SingletonList (rsrcA))).ThenReturn(new MockLocalizerHeartbeatResponse(LocalizerAction.Live, Sharpen.Collections .SingletonList(rsrcB))).ThenReturn(new MockLocalizerHeartbeatResponse(LocalizerAction .Live, Sharpen.Collections.SingletonList(rsrcC))).ThenReturn(new MockLocalizerHeartbeatResponse (LocalizerAction.Live, Sharpen.Collections.SingletonList(rsrcD))).ThenReturn(new MockLocalizerHeartbeatResponse(LocalizerAction.Live, Sharpen.Collections.EmptyList <ResourceLocalizationSpec>())).ThenReturn(new MockLocalizerHeartbeatResponse(LocalizerAction .Die, null)); LocalResource tRsrcA = rsrcA.GetResource(); LocalResource tRsrcB = rsrcB.GetResource(); LocalResource tRsrcC = rsrcC.GetResource(); LocalResource tRsrcD = rsrcD.GetResource(); Org.Mockito.Mockito.DoReturn(new TestContainerLocalizer.FakeDownload(rsrcA.GetResource ().GetResource().GetFile(), true)).When(localizer).Download(Matchers.IsA <Path>() , Matchers.Eq(tRsrcA), Matchers.IsA <UserGroupInformation>()); Org.Mockito.Mockito.DoReturn(new TestContainerLocalizer.FakeDownload(rsrcB.GetResource ().GetResource().GetFile(), true)).When(localizer).Download(Matchers.IsA <Path>() , Matchers.Eq(tRsrcB), Matchers.IsA <UserGroupInformation>()); Org.Mockito.Mockito.DoReturn(new TestContainerLocalizer.FakeDownload(rsrcC.GetResource ().GetResource().GetFile(), true)).When(localizer).Download(Matchers.IsA <Path>() , Matchers.Eq(tRsrcC), Matchers.IsA <UserGroupInformation>()); Org.Mockito.Mockito.DoReturn(new TestContainerLocalizer.FakeDownload(rsrcD.GetResource ().GetResource().GetFile(), true)).When(localizer).Download(Matchers.IsA <Path>() , Matchers.Eq(tRsrcD), Matchers.IsA <UserGroupInformation>()); // run localization NUnit.Framework.Assert.AreEqual(0, localizer.RunLocalization(nmAddr)); foreach (Path p_1 in localDirs) { Path @base = new Path(new Path(p_1, ContainerLocalizer.Usercache), appUser); Path privcache = new Path(@base, ContainerLocalizer.Filecache); // $x/usercache/$user/filecache Org.Mockito.Mockito.Verify(spylfs).Mkdir(Matchers.Eq(privcache), Matchers.Eq(CacheDirPerm ), Matchers.Eq(false)); Path appDir = new Path(@base, new Path(ContainerLocalizer.Appcache, appId)); // $x/usercache/$user/appcache/$appId/filecache Path appcache = new Path(appDir, ContainerLocalizer.Filecache); Org.Mockito.Mockito.Verify(spylfs).Mkdir(Matchers.Eq(appcache), Matchers.Eq(CacheDirPerm ), Matchers.Eq(false)); } // verify tokens read at expected location Org.Mockito.Mockito.Verify(spylfs).Open(tokenPath); // verify downloaded resources reported to NM Org.Mockito.Mockito.Verify(nmProxy).Heartbeat(Matchers.ArgThat(new TestContainerLocalizer.HBMatches (rsrcA.GetResource()))); Org.Mockito.Mockito.Verify(nmProxy).Heartbeat(Matchers.ArgThat(new TestContainerLocalizer.HBMatches (rsrcB.GetResource()))); Org.Mockito.Mockito.Verify(nmProxy).Heartbeat(Matchers.ArgThat(new TestContainerLocalizer.HBMatches (rsrcC.GetResource()))); Org.Mockito.Mockito.Verify(nmProxy).Heartbeat(Matchers.ArgThat(new TestContainerLocalizer.HBMatches (rsrcD.GetResource()))); // verify all HB use localizerID provided Org.Mockito.Mockito.Verify(nmProxy, Org.Mockito.Mockito.Never()).Heartbeat(Matchers.ArgThat (new _ArgumentMatcher_193())); }
/// <exception cref="System.IO.IOException"/> /// <exception cref="URISyntaxException"/> public ChecksumFs(AbstractFileSystem theFs) : base(theFs) { defaultBytesPerChecksum = GetMyFs().GetServerDefaults().GetBytesPerChecksum(); }