public void TestReplicaStatus() { var replica = new ReplicaInfo(); Assert.IsTrue(replica.Status != ReplicaStatus.None); // - None replica.Status = ReplicaStatus.None; Assert.IsTrue(replica.IsReadOnly() == false); Assert.IsTrue(replica.IsReadable() == false); Assert.IsTrue(replica.IsWriteOnly() == false); Assert.IsTrue(replica.IsWritable() == false); // - RO replica.Status = ReplicaStatus.ReadOnly; Assert.IsTrue(replica.IsReadOnly() == true); Assert.IsTrue(replica.IsReadable() == true); Assert.IsTrue(replica.IsWriteOnly() == false); Assert.IsTrue(replica.IsWritable() == false); // WO replica.Status = ReplicaStatus.WriteOnly; Assert.IsTrue(replica.IsReadOnly() == false); Assert.IsTrue(replica.IsReadable() == false); Assert.IsTrue(replica.IsWriteOnly() == true); Assert.IsTrue(replica.IsWritable() == true); // RW replica.Status = ReplicaStatus.ReadWrite; Assert.IsTrue(replica.IsReadOnly() == false); Assert.IsTrue(replica.IsReadable() == true); Assert.IsTrue(replica.IsWriteOnly() == false); Assert.IsTrue(replica.IsWritable() == true); }
public void DeserializeProperties_should_ignore_null_and_empty_values() { var dict = new Dictionary <string, string> { { "a", "a-value" }, { "b", null }, { "c", "" }, { "d", " " } }; var replicaInfo = new ReplicaInfo( "default", "vostok", "doesntmatter", dict); var serialized = ReplicaNodeDataSerializer.Serialize(replicaInfo); var deserialized = ReplicaNodeDataSerializer.Deserialize(replicaInfo.Environment, replicaInfo.Application, replicaInfo.Replica, serialized); deserialized.Properties.Should() .BeEquivalentTo( new Dictionary <string, string> { { "a", "a-value" }, { "d", " " } }); }
protected void DeleteReplicaNode(ReplicaInfo replicaInfo) { var path = PathHelper.BuildReplicaPath(replicaInfo.Environment, replicaInfo.Application, replicaInfo.Replica); var delete = ZooKeeperClient.Delete(path); delete.IsSuccessful.Should().BeTrue(); }
protected void CreateReplicaNode(ReplicaInfo replicaInfo, bool persistent = true) { var data = ReplicaNodeDataSerializer.Serialize(replicaInfo); var path = PathHelper.BuildReplicaPath(replicaInfo.Environment, replicaInfo.Application, replicaInfo.Replica); CreateOrUpdate(path, data, persistent); }
public void Should_return_same_topology_instance_if_nothing_changed() { var replica1 = new ReplicaInfo("default", "vostok", "https://github.com/vostok1"); var replica2 = new ReplicaInfo("default", "vostok", "https://github.com/vostok2"); CreateEnvironmentNode("default"); CreateApplicationNode("default", "vostok"); CreateReplicaNode(replica1); using (var locator = GetServiceLocator()) { var topo1 = locator.Locate("default", "vostok"); var topo2 = locator.Locate("default", "vostok"); ReferenceEquals(topo1, topo2).Should().BeTrue(); CreateEnvironmentNode("default", "parent"); var topo3 = locator.Locate("default", "vostok"); ReferenceEquals(topo2, topo3).Should().BeTrue(); CreateReplicaNode(replica2); // ReSharper disable once AccessToDisposedClosure Action action = () => ReferenceEquals(topo3, locator.Locate("default", "vostok")).Should().BeFalse(); action.ShouldPassIn(DefaultTimeout); } }
/// <summary> /// Gets the object from Json properties. /// </summary> /// <param name="reader">The <see cref="T: Newtonsoft.Json.JsonReader" /> to read from.</param> /// <returns>The object Value.</returns> internal static ReplicaInfo GetFromJsonProperties(JsonReader reader) { ReplicaInfo obj = null; var propName = reader.ReadPropertyName(); if (!propName.Equals("ServiceKind", StringComparison.OrdinalIgnoreCase)) { throw new JsonReaderException($"Incorrect discriminator property name {propName}, Expected discriminator property name is ServiceKind."); } var propValue = reader.ReadValueAsString(); if (propValue.Equals("Stateful", StringComparison.OrdinalIgnoreCase)) { obj = StatefulServiceReplicaInfoConverter.GetFromJsonProperties(reader); } else if (propValue.Equals("Stateless", StringComparison.OrdinalIgnoreCase)) { obj = StatelessServiceInstanceInfoConverter.GetFromJsonProperties(reader); } else { throw new InvalidOperationException("Unknown ServiceKind."); } return(obj); }
protected bool ReplicaRegistered(ReplicaInfo replica) { var path = PathHelper.BuildReplicaPath(replica.Environment, replica.Application, replica.Replica); var exists = ZooKeeperClient.Exists(path); return(exists.Exists); }
public void ResolveConflictLocalWins(SyncConflict conflict) { if (_closed) { throw new InvalidOperationException(); } var tickCount = _store.IncrementLocalRepilcaTickCount(); var modifiedReplica = new ReplicaInfo { ReplicaId = _store.GetLocalReplicaId(), ReplicaTickCount = tickCount }; var resolvedStatus = conflict.LocalItemInfo.Deleted ? SyncStatus.Delete : SyncStatus.Update; var data = JObject.Parse("{item:{itemRefs:[]}}"); if (resolvedStatus != SyncStatus.Delete) { var builder = SyncUtil.JsonItemFromSyncableItemInfo(conflict.LocalItemInfo); _store.BuildItemData(conflict.LocalItemInfo, builder); data = new JObject { { "item", builder } }; } using (var connection = _syncSessionDbConnectionProvider.GetSyncSessionDbConnection(_localSessionId)) { SessionDbHelper.ResolveItemWithData(connection, conflict.RemoteItemInfo, resolvedStatus, modifiedReplica, data); } }
public void Should_locate_multiple_registered_ServiceBeacon_services_in_multiple_environments() { var replica11 = new ReplicaInfo("A", "vostok", "https://github.com/vostok/A1"); var replica12 = new ReplicaInfo("A", "vostok", "https://github.com/vostok/A2"); var replica2 = new ReplicaInfo("A", "not-vostok", "https://github.com/not-vostok/A"); var replica3 = new ReplicaInfo("B", "vostok", "https://github.com/vostok/B"); CreateEnvironmentNode("A"); CreateEnvironmentNode("B"); using (var beacon11 = GetServiceBeacon(replica11)) using (var beacon12 = GetServiceBeacon(replica12)) using (var beacon2 = GetServiceBeacon(replica3)) using (var beacon3 = GetServiceBeacon(replica2)) { beacon11.Start(); beacon12.Start(); beacon2.Start(); beacon3.Start(); WaitReplicaRegistered(replica11); WaitReplicaRegistered(replica12); WaitReplicaRegistered(replica2); WaitReplicaRegistered(replica3); using (var locator = GetServiceLocator()) { ShouldLocateImmediately(locator, "A", "vostok", replica11.Replica, replica12.Replica); ShouldLocateImmediately(locator, "A", "not-vostok", replica2.Replica); ShouldLocateImmediately(locator, "B", "vostok", replica3.Replica); } } }
public void Should_skip_environment_with_application_if_specified() { var replicaParent = new ReplicaInfo("parent", "vostok", "https://github.com/vostok/parent"); var replicaChild = new ReplicaInfo("child", "vostok", "https://github.com/vostok/child"); CreateEnvironmentNode("parent"); CreateEnvironmentNode("child", "parent", new Dictionary <string, string> { { EnvironmentInfoKeys.SkipIfEmpty, "True" } }); CreateApplicationNode("child", "vostok"); CreateApplicationNode("parent", "vostok"); CreateReplicaNode(replicaParent); using (var locator = GetServiceLocator()) { ShouldLocate(locator, "child", "vostok", replicaParent.Replica); ShouldLocate(locator, "parent", "vostok", replicaParent.Replica); CreateReplicaNode(replicaChild); ShouldLocate(locator, "child", "vostok", replicaChild.Replica); ShouldLocate(locator, "parent", "vostok", replicaParent.Replica); } }
public void Should_locate_registered_ServiceBeacon_service_with_custom_path_escaper() { var replica = new ReplicaInfo("default", "vostok", "https://github.com/vostok"); ZooKeeperClient.Create("/service-discovery/v2/ZGVmYXVsdA==", CreateMode.Persistent); using (var beacon = new ServiceBeacon( ZooKeeperClient, replica, new ServiceBeaconSettings { IterationPeriod = 60.Seconds(), MinimumTimeBetweenIterations = 100.Milliseconds(), ZooKeeperNodesPathEscaper = new CustomPathEscaper() }, Log)) { beacon.Start(); WaitNodeExists("/service-discovery/v2/ZGVmYXVsdA==/dm9zdG9r/aHR0cHM6Ly9naXRodWIuY29tL3Zvc3Rvaw=="); using (var locator = new ServiceLocator( ZooKeeperClient, new ServiceLocatorSettings { ZooKeeperNodesPathEscaper = new CustomPathEscaper() }, Log)) { ShouldLocateImmediately(locator, replica.Environment, replica.Application, replica.Replica); } } }
public void Should_track_environment_properties() { var replicaParent = new ReplicaInfo("parent", "vostok", "https://github.com/vostok/parent"); CreateEnvironmentNode("parent"); CreateEnvironmentNode("child", "parent", new Dictionary <string, string> { { EnvironmentInfoKeys.SkipIfEmpty, "True" } }); CreateApplicationNode("child", "vostok"); CreateApplicationNode("parent", "vostok"); CreateReplicaNode(replicaParent); using (var locator = GetServiceLocator()) { ShouldLocate(locator, "child", "vostok", replicaParent.Replica); ShouldLocate(locator, "parent", "vostok", replicaParent.Replica); CreateEnvironmentNode("child", "parent", new Dictionary <string, string> { { EnvironmentInfoKeys.SkipIfEmpty, "False" } }); ShouldLocate(locator, "child", "vostok"); ShouldLocate(locator, "parent", "vostok", replicaParent.Replica); } }
/// <exception cref="System.IO.IOException"/> private void TestRbwReplicas(MiniDFSCluster cluster, bool isCorrupt) { FSDataOutputStream @out = null; FileSystem fs = cluster.GetFileSystem(); Path src = new Path("/test.txt"); try { int fileLen = 515; // create some rbw replicas on disk byte[] writeBuf = new byte[fileLen]; new Random().NextBytes(writeBuf); @out = fs.Create(src); @out.Write(writeBuf); @out.Hflush(); DataNode dn = cluster.GetDataNodes()[0]; foreach (FsVolumeSpi v in Dataset(dn).GetVolumes()) { FsVolumeImpl volume = (FsVolumeImpl)v; FilePath currentDir = volume.GetCurrentDir().GetParentFile().GetParentFile(); FilePath rbwDir = new FilePath(currentDir, "rbw"); foreach (FilePath file in rbwDir.ListFiles()) { if (isCorrupt && Block.IsBlockFilename(file)) { new RandomAccessFile(file, "rw").SetLength(fileLen - 1); } } } // corrupt cluster.RestartDataNodes(); cluster.WaitActive(); dn = cluster.GetDataNodes()[0]; // check volumeMap: one rwr replica string bpid = cluster.GetNamesystem().GetBlockPoolId(); ReplicaMap replicas = Dataset(dn).volumeMap; NUnit.Framework.Assert.AreEqual(1, replicas.Size(bpid)); ReplicaInfo replica = replicas.Replicas(bpid).GetEnumerator().Next(); NUnit.Framework.Assert.AreEqual(HdfsServerConstants.ReplicaState.Rwr, replica.GetState ()); if (isCorrupt) { NUnit.Framework.Assert.AreEqual((fileLen - 1) / 512 * 512, replica.GetNumBytes()); } else { NUnit.Framework.Assert.AreEqual(fileLen, replica.GetNumBytes()); } Dataset(dn).Invalidate(bpid, new Block[] { replica }); } finally { IOUtils.CloseStream(@out); if (fs.Exists(src)) { fs.Delete(src, false); } fs.Close(); } }
public void Should_track_application_properties() { var replica = new ReplicaInfo("default", "vostok", "https://github.com/vostok"); var properties = new Dictionary <string, string> { { "key1", "value1" }, { "key2", "value2" } }; CreateEnvironmentNode("default"); CreateApplicationNode("default", "vostok", properties); CreateReplicaNode(replica); using (var locator = GetServiceLocator()) { // ReSharper disable once PossibleNullReferenceException locator.Locate("default", "vostok").Properties.Should().BeEquivalentTo(properties); for (var times = 0; times < 5; times++) { properties["iteration"] = times.ToString(); CreateApplicationNode("default", "vostok", properties); // ReSharper disable once AccessToDisposedClosure // ReSharper disable once PossibleNullReferenceException Action action = () => { locator.Locate("default", "vostok").Properties.Should().BeEquivalentTo(properties); }; action.ShouldPassIn(DefaultTimeout); } } }
public void Should_locate_registered_ServiceBeacon_services_and_ignore_daemons_without_port() { var service1 = new ReplicaInfo("default", "vostok", "https://github.com/vostok/1"); var service2 = new ReplicaInfo("default", "vostok", "https://github.com/vostok/2"); var daemon = new ReplicaInfo("default", "vostok", "pid(123)"); CreateEnvironmentNode("default"); CreateApplicationNode("default", "vostok"); using (var service1Beacon = GetServiceBeacon(service1)) using (var locator = GetServiceLocator()) { service1Beacon.Start(); WaitReplicaRegistered(service1); ShouldLocateImmediately(locator, "default", "vostok", service1.Replica); using (var daemonBeacon = GetServiceBeacon(daemon)) { daemonBeacon.Start(); WaitReplicaRegistered(daemon); Thread.Sleep(0.5.Seconds()); ShouldLocateImmediately(locator, "default", "vostok", service1.Replica); using (var service2Beacon = GetServiceBeacon(service2)) { service2Beacon.Start(); WaitReplicaRegistered(service2); ShouldLocate(locator, "default", "vostok", service1.Replica, service2.Replica); } } } }
public void TryCreatePermanentReplicaAsync_should_return_true_and_create_new_replica_environment_and_application_if_they_do_not_exist() { var replicaInfo = new ReplicaInfo("default", "vostok", "replica1", GetProperties()); var serviceDiscoveryManager = new ServiceDiscoveryManager(GetZooKeeperClient(), log: Log); serviceDiscoveryManager.TryCreatePermanentReplicaAsync(replicaInfo) .GetAwaiter() .GetResult() .Should() .BeTrue(); serviceDiscoveryManager .GetAllReplicasAsync(replicaInfo.Environment, replicaInfo.Application) .GetAwaiter() .GetResult() .Should() .BeEquivalentTo("replica1"); serviceDiscoveryManager .GetEnvironmentAsync("default") .GetAwaiter() .GetResult() .Should() .NotBeNull(); serviceDiscoveryManager .GetApplicationAsync("default", "vostok") .GetAwaiter() .GetResult() .Should() .NotBeNull(); }
/// <exception cref="System.IO.IOException"/> public static bool UnlinkBlock <_T0>(FsDatasetSpi <_T0> fsd, ExtendedBlock block, int numLinks) where _T0 : FsVolumeSpi { ReplicaInfo info = ((FsDatasetImpl)fsd).GetReplicaInfo(block); return(info.UnlinkBlock(numLinks)); }
public void Should_not_throw_immediately_disposed() { var replica = new ReplicaInfo("default", "vostok", "https://github.com/vostok"); using (GetServiceBeacon(replica)) { } }
public virtual void TestRecoverReplicas() { Configuration conf = new HdfsConfiguration(); conf.SetLong(DFSConfigKeys.DfsBlockSizeKey, 1024L); conf.SetInt(DFSConfigKeys.DfsClientWritePacketSizeKey, 512); MiniDFSCluster cluster = new MiniDFSCluster.Builder(conf).Build(); cluster.WaitActive(); try { FileSystem fs = cluster.GetFileSystem(); for (int i = 0; i < 4; i++) { Path fileName = new Path("/test" + i); DFSTestUtil.CreateFile(fs, fileName, 1, (short)1, 0L); DFSTestUtil.WaitReplication(fs, fileName, (short)1); } string bpid = cluster.GetNamesystem().GetBlockPoolId(); DataNode dn = cluster.GetDataNodes()[0]; IEnumerator <ReplicaInfo> replicasItor = Dataset(dn).volumeMap.Replicas(bpid).GetEnumerator (); ReplicaInfo replica = replicasItor.Next(); CreateUnlinkTmpFile(replica, true, true); // rename block file CreateUnlinkTmpFile(replica, false, true); // rename meta file replica = replicasItor.Next(); CreateUnlinkTmpFile(replica, true, false); // copy block file CreateUnlinkTmpFile(replica, false, false); // copy meta file replica = replicasItor.Next(); CreateUnlinkTmpFile(replica, true, true); // rename block file CreateUnlinkTmpFile(replica, false, false); // copy meta file cluster.RestartDataNodes(); cluster.WaitActive(); dn = cluster.GetDataNodes()[0]; // check volumeMap: 4 finalized replica ICollection <ReplicaInfo> replicas = Dataset(dn).volumeMap.Replicas(bpid); NUnit.Framework.Assert.AreEqual(4, replicas.Count); replicasItor = replicas.GetEnumerator(); while (replicasItor.HasNext()) { NUnit.Framework.Assert.AreEqual(HdfsServerConstants.ReplicaState.Finalized, replicasItor .Next().GetState()); } } finally { cluster.Shutdown(); } }
/// <summary> /// Helper function to return the RTableConfig /// Note that even if 3 (say) accounts are specified in the xml, /// the test codes can specify that only accounts #0 and #2 are used to construct the RTable. /// </summary> /// <param name="viewId"></param> /// <param name="convertXStoreTableMode"></param> /// <param name="readViewHeadIndex"></param> /// <returns></returns> private ReplicatedTableConfiguration GetRTableConfiguration(long viewId, bool convertXStoreTableMode, int readViewHeadIndex = 0) { if (viewId <= 0) { throw new Exception(string.Format("GetRTableConfigText() was called with invalid viewId {0}", viewId)); } // 1 - Create a default view var viewConfig = new ReplicatedTableConfigurationStore { ViewId = viewId, ReadViewHeadIndex = readViewHeadIndex, }; int numberOfStorageAccounts = this.rtableTestConfiguration.StorageInformation.AccountNames.Count(); for (int i = 0; i < this.actualStorageAccountsUsed.Count; i++) { int index = this.actualStorageAccountsUsed[i]; if (index < 0 || index > numberOfStorageAccounts) { throw new Exception(string.Format("this.actualStorageAccountsUsed[{0}] = {1} is out of range.", i, index)); } ReplicaInfo replica = new ReplicaInfo { StorageAccountName = this.rtableTestConfiguration.StorageInformation.AccountNames[index], Status = ReplicaStatus.ReadWrite, }; if (readViewHeadIndex != 0 && i < readViewHeadIndex) { replica.Status = ReplicaStatus.WriteOnly; } viewConfig.ReplicaChain.Add(replica); } // 2 - Create a default table config. that references the "DefaultView" var tableConfig = new ReplicatedTableConfiguredTable { TableName = DefaultTableConfigName, ViewName = DefaultViewName, ConvertToRTable = convertXStoreTableMode, UseAsDefault = true, }; // 3 - Create the final RTable configuration ReplicatedTableConfiguration configuration = new ReplicatedTableConfiguration(); configuration.SetView(DefaultViewName, viewConfig); configuration.SetTable(tableConfig); return(configuration); }
protected ServiceBeacon GetServiceBeacon(ReplicaInfo replica, ZooKeeperClient client = null, Func <bool> registrationAllowedProvider = null) { client = client ?? ZooKeeperClient; var settings = new ServiceBeaconSettings { IterationPeriod = 60.Seconds(), MinimumTimeBetweenIterations = 100.Milliseconds(), RegistrationAllowedProvider = registrationAllowedProvider }; return(new ServiceBeacon(client, replica, settings, Log)); }
public void Should_ignore_cycled_if_resolved() { var replica = new ReplicaInfo("default", "vostok", "https://github.com/vostok"); CreateEnvironmentNode("default", "default"); CreateReplicaNode(replica); using (var locator = GetServiceLocator()) { ShouldLocate(locator, "default", "vostok", replica.Replica); } }
private static void AssertEquals(ReplicaInfo originalInfo, ReplicaRecoveryInfo recoveryInfo ) { NUnit.Framework.Assert.AreEqual(originalInfo.GetBlockId(), recoveryInfo.GetBlockId ()); NUnit.Framework.Assert.AreEqual(originalInfo.GetGenerationStamp(), recoveryInfo.GetGenerationStamp ()); NUnit.Framework.Assert.AreEqual(originalInfo.GetBytesOnDisk(), recoveryInfo.GetNumBytes ()); NUnit.Framework.Assert.AreEqual(originalInfo.GetState(), recoveryInfo.GetOriginalReplicaState ()); }
/// <summary> /// Get the meta information of the replica that matches both block id /// and generation stamp /// </summary> /// <param name="bpid">block pool id</param> /// <param name="block">block with its id as the key</param> /// <returns>the replica's meta information</returns> /// <exception cref="System.ArgumentException">if the input block or block pool is null /// </exception> internal virtual ReplicaInfo Get(string bpid, Block block) { CheckBlockPool(bpid); CheckBlock(block); ReplicaInfo replicaInfo = Get(bpid, block.GetBlockId()); if (replicaInfo != null && block.GetGenerationStamp() == replicaInfo.GetGenerationStamp ()) { return(replicaInfo); } return(null); }
protected ISyncableItemInfo getSyncableItemInfoFrom(ReplicaItemId reposItemId) { IReplicaInfo created = new ReplicaInfo { ReplicaId = Adapter.GetGlobalReplicaIdForLocalReplicaId(reposItemId.CreationReplicaLocalId), ReplicaTickCount = reposItemId.CreationTickCount }; IReplicaInfo modified = new ReplicaInfo { ReplicaId = Adapter.GetGlobalReplicaIdForLocalReplicaId(reposItemId.ModificationReplicaLocalId), ReplicaTickCount = reposItemId.ModificationTickCount }; return(new SyncableItemInfo { ItemType = reposItemId.ItemType.ToString(), Created = created, Modified = modified, Deleted = false }); }
public void AddReplicaTest() { Assert.IsTrue(this.repTable.Exists(), "RTable does not exist"); View v = this.configurationWrapper.GetWriteView(); int index = v.Chain.Count - 1; string accountName = v.GetReplicaInfo(index).StorageAccountName; List <ReplicaInfo> replicas = new List <ReplicaInfo>(); for (int i = 0; i <= index; i++) { replicas.Add(v.Chain[i].Item1); } //Just add the last replica again at the head to simulate a new replica addition ReplicaInfo newReplica = new ReplicaInfo() { StorageAccountName = accountName, }; //Add the new replica at the head replicas.Insert(0, newReplica); int readViewHeadIndex = 1; this.UpdateConfiguration(replicas, readViewHeadIndex); // validate all state Assert.IsFalse(this.configurationWrapper.IsViewStable(), "View = {0}", this.configurationWrapper.GetWriteView().IsStable); View readView = this.configurationWrapper.GetReadView(); View writeView = this.configurationWrapper.GetWriteView(); long viewIdAfterFirstUpdate = writeView.ViewId; // Actually, both read and write views point to the same view Assert.IsTrue(readView == writeView); int headIndex = 0; long readViewHeadViewId = readView.GetReplicaInfo(readViewHeadIndex).ViewInWhichAddedToChain; Assert.IsTrue(writeView.GetReplicaInfo(headIndex).ViewInWhichAddedToChain == readViewHeadViewId + 1); //Now, make the read and write views the same this.UpdateConfiguration(replicas, 0); // validate all state Assert.IsTrue(this.configurationWrapper.IsViewStable()); readView = this.configurationWrapper.GetReadView(); writeView = this.configurationWrapper.GetWriteView(); Assert.IsTrue(readView == writeView); Assert.IsTrue(readView.ViewId == viewIdAfterFirstUpdate + 1); }
public void GetApplicationAsync_should_return_not_null_if_application_exists() { var replica = new ReplicaInfo("default", "vostok", "https://github.com/vostok"); CreateApplicationNode(replica.Environment, replica.Application); var serviceDiscoveryManager = new ServiceDiscoveryManager(GetZooKeeperClient(), log: Log); serviceDiscoveryManager.GetApplicationAsync(replica.Environment, replica.Application) .GetAwaiter() .GetResult() .Should() .BeEquivalentTo(new ApplicationInfo(replica.Environment, replica.Application, null)); }
public void GetEnvironmentAsync_should_return_not_null_if_environment_exists() { var replica = new ReplicaInfo("default", "vostok", "https://github.com/vostok"); CreateEnvironmentNode(replica.Environment); var serviceDiscoveryManager = new ServiceDiscoveryManager(GetZooKeeperClient(), log: Log); serviceDiscoveryManager.GetEnvironmentAsync(replica.Environment) .GetAwaiter() .GetResult() .Should() .NotBeNull(); }
public void TestToString() { var replica = new ReplicaInfo(); string acc = "some_name"; string key = "some_key"; int whenAddedToChain = 8; replica.StorageAccountName = acc; replica.StorageAccountKey = key; replica.ViewInWhichAddedToChain = whenAddedToChain; replica.Status = ReplicaStatus.ReadWrite; Assert.IsTrue(replica.ToString() == string.Format("Account Name: {0}, AccountKey: {1}, ViewInWhichAddedToChain: {2}, Status: {3}", acc, "***********", whenAddedToChain, ReplicaStatus.ReadWrite)); }
public void Start_should_create_node() { var replica = new ReplicaInfo("default", "vostok", "https://github.com/vostok"); CreateEnvironmentNode(replica.Environment); using (var beacon = GetServiceBeacon(replica)) { ReplicaRegistered(replica).Should().BeFalse(); beacon.Start(); beacon.WaitForInitialRegistrationAsync().ShouldCompleteIn(DefaultTimeout); ReplicaRegistered(replica).Should().BeTrue(); } }