public void TestExists() { using (var requestHandler = new TestRequestHandler()) using (var client = new RingMasterClient(requestHandler)) { string path = this.GetRandomString(); var version = this.GetRandomInt(); var watcher = new TestWatcher(this.GetRandomInt()); var expectedStat = new Stat() { Version = this.GetRandomInt() }; requestHandler.Implementation = request => { Assert.IsTrue(request is RequestExists); var existsRequest = (RequestExists)request; Assert.AreEqual(path, existsRequest.Path); Assert.AreEqual(watcher.Id, existsRequest.Watcher.Id); return(new RequestResponse() { ResultCode = (int)RingMasterException.Code.Ok, Content = expectedStat }); }; client.SetWatcher(watcher); IStat stat = client.Exists(path, watch: true).Result; Assert.IsNotNull(stat); Assert.AreEqual(expectedStat.Version, stat.Version); } }
protected IRingMasterRequestHandler ConnectToRingMaster() { SimpleTransport clientTransport = null; IRingMasterRequestHandler ringMaster = null; bool mustDispose = true; try { var configuration = new RingMasterClient.Configuration(); IRingMasterClientInstrumentation instrumentation = new RingMasterClientInstrumentation(); clientTransport = new SimpleTransport(); ringMaster = new RingMasterClient(configuration, instrumentation, this.protocol, clientTransport, CancellationToken.None); clientTransport.Connect(this.serverTransport); mustDispose = false; return(ringMaster); } finally { if (mustDispose) { ringMaster.Dispose(); clientTransport.Dispose(); } } }
public void TestMove() { using (var requestHandler = new TestRequestHandler()) using (var client = new RingMasterClient(requestHandler)) { string pathSrc = this.GetRandomString(); string pathDst = this.GetRandomString(); var version = this.GetRandomInt(); var moveMode = MoveMode.AllowPathCreationFlag; var expectedResult = this.GetRandomString(); requestHandler.Implementation = request => { Assert.IsTrue(request is RequestMove); var moveRequest = (RequestMove)request; Assert.AreEqual(pathSrc, moveRequest.Path); Assert.AreEqual(pathDst, moveRequest.PathDst); Assert.AreEqual(version, moveRequest.Version); Assert.AreEqual(moveMode, moveRequest.MoveMode); return(new RequestResponse() { ResultCode = (int)RingMasterException.Code.Ok, Content = expectedResult }); }; string result = client.Move(pathSrc, version, pathDst, moveMode).Result; Assert.AreEqual(expectedResult, result); } }
public void TestCreateDontThrowIfNodeExists() { using (var requestHandler = new TestRequestHandler()) using (var client = new RingMasterClient(requestHandler)) { string path = this.GetRandomString(); byte[] data = this.GetRandomData(); var acl = new List <Acl>() { new Acl((int)Acl.Perm.ALL, new Id(AuthSchemes.Digest, this.GetRandomString())) }; var createMode = CreateMode.Persistent; var expectedResult = this.GetRandomString(); requestHandler.Implementation = request => { Assert.IsTrue(request is RequestCreate); var createRequest = (RequestCreate)request; Assert.AreEqual(path, createRequest.Path); Assert.AreEqual(data, createRequest.Data); Assert.AreEqual(acl.Count, createRequest.Acl.Count); Assert.IsTrue(Acl.AreEqual(acl[0], createRequest.Acl[0])); Assert.AreEqual(createMode, createRequest.CreateMode); return(new RequestResponse() { ResultCode = (int)RingMasterException.Code.Nodeexists, Content = expectedResult }); }; client.Create(path, data, acl, createMode, throwIfNodeExists: false).Wait(); } }
public void TestConstructorWithServerSpec() { var serverSpec = new RingMasterClient.ServerSpec(); serverSpec.Endpoints = new IPEndPoint[] { new IPEndPoint(IPAddress.Loopback, 0) }; serverSpec.UseSecureConnection = true; serverSpec.ClientCertificate = GetLocalCertificates(1)[0]; serverSpec.AcceptedServerCertificates = GetLocalCertificates(1); var configuration = new RingMasterClient.Configuration(); configuration.DefaultTimeout = Timeout.InfiniteTimeSpan; configuration.HeartBeatInterval = Timeout.InfiniteTimeSpan; configuration.RequestQueueLength = int.MaxValue; configuration.BufferSize = int.MaxValue; var instrumentation = new RingMasterClientInstrumentation(); try { using (var client = new RingMasterClient(serverSpec, configuration, instrumentation, new CancellationToken(true))) { client.Sync("/").Wait(); } } catch (Exception) { } }
public void TestSetData() { using (var requestHandler = new TestRequestHandler()) using (var client = new RingMasterClient(requestHandler)) { string path = this.GetRandomString(); int version = this.GetRandomInt(); byte[] data = this.GetRandomData(); var expectedStat = new Stat() { Version = this.GetRandomInt() }; requestHandler.Implementation = request => { Assert.IsTrue(request is RequestSetData); var setDataRequest = (RequestSetData)request; Assert.AreEqual(path, setDataRequest.Path); Assert.AreEqual(version, setDataRequest.Version); CollectionAssert.AreEqual(data, setDataRequest.Data); return(new RequestResponse() { ResultCode = (int)RingMasterException.Code.Ok, Stat = expectedStat }); }; var stat = client.SetData(path, data, version).Result; Assert.AreEqual(expectedStat.Version, stat.Version); } }
public void TestGetDataWithStat() { using (var requestHandler = new TestRequestHandler()) using (var client = new RingMasterClient(requestHandler)) { string path = this.GetRandomString(); var watcher = new TestWatcher(this.GetRandomInt()); byte[] expectedData = this.GetRandomData(); var expectedStat = new Stat() { Version = this.GetRandomInt() }; requestHandler.Implementation = request => { Assert.IsTrue(request is RequestGetData); var getDataRequest = (RequestGetData)request; Assert.AreEqual(path, getDataRequest.Path); Assert.AreEqual(watcher.Id, getDataRequest.Watcher.Id); return(new RequestResponse() { ResultCode = (int)RingMasterException.Code.Ok, Content = expectedData, Stat = expectedStat }); }; var dataAndStat = client.GetDataWithStat(path, watcher).Result; Assert.AreEqual(expectedStat.Version, dataAndStat.Item1.Version); CollectionAssert.AreEqual(expectedData, dataAndStat.Item2); } }
public void TestSetACL() { using (var requestHandler = new TestRequestHandler()) using (var client = new RingMasterClient(requestHandler)) { string path = this.GetRandomString(); var version = this.GetRandomInt(); var acl = new List <Acl>() { new Acl((int)Acl.Perm.ALL, new Id(AuthSchemes.Digest, this.GetRandomString())) }; var expectedStat = new Stat() { Version = this.GetRandomInt() }; requestHandler.Implementation = request => { Assert.IsTrue(request is RequestSetAcl); var setAclRequest = (RequestSetAcl)request; Assert.AreEqual(path, setAclRequest.Path); Assert.AreEqual(acl.Count, setAclRequest.Acl.Count); Assert.IsTrue(Acl.AreEqual(acl[0], setAclRequest.Acl[0])); return(new RequestResponse() { ResultCode = (int)RingMasterException.Code.Ok, Stat = expectedStat }); }; var stat = client.SetACL(path, acl, version).Result; Assert.AreEqual(expectedStat.Version, stat.Version); } }
public void TestNullConfiguration() { var instrumentation = new RingMasterClientInstrumentation(); try { var serverSpec = new RingMasterClient.ServerSpec(); using (var ringMaster = new RingMasterClient(serverSpec, null, instrumentation, CancellationToken.None)) { Assert.Fail("ArgumentNullException should have been thrown"); } } catch (ArgumentNullException) { } var protocol = new RingMasterCommunicationProtocol(); try { using (var clientTransport = new SimpleTransport()) using (var ringMaster = new RingMasterClient(null, instrumentation, protocol, clientTransport, CancellationToken.None)) { Assert.Fail("ArgumentNullException should have been thrown"); } } catch (ArgumentNullException) { } }
/// <summary> /// Creates the ring master connection. /// </summary> /// <param name="connectionString">The connection string.</param> /// <param name="cancellationToken">The cancellation token.</param> /// <param name="timeStreamId">The time stream identifier.</param> /// <returns>ring master client connection</returns> public static IRingMasterRequestHandler CreateRingMasterTimeStreamRequestHandler(string connectionString, CancellationToken cancellationToken, ulong timeStreamId) { var configuration = new RingMasterClient.Configuration(); var ringMaster = new RingMasterClient(connectionString, configuration, null, cancellationToken); return(ringMaster.OpenTimeStream(timeStreamId)); }
public void TestDelete() { using (var requestHandler = new TestRequestHandler()) using (var client = new RingMasterClient(requestHandler)) { string path = this.GetRandomString(); var version = this.GetRandomInt(); requestHandler.Implementation = request => { Assert.IsTrue(request is RequestDelete); var deleteRequest = (RequestDelete)request; Assert.AreEqual(path, deleteRequest.Path); Assert.AreEqual(version, deleteRequest.Version); return(new RequestResponse() { ResultCode = (deleteRequest.DeleteMode == DeleteMode.None) ? (int)RingMasterException.Code.Ok : (int)RingMasterException.Code.Nonode }); }; bool result = client.Delete(path, version, isRecursive: false).Result; Assert.IsTrue(result); result = client.Delete(path, version, isRecursive: true).Result; Assert.IsFalse(result); } }
public void TestGetChildren() { using (var requestHandler = new TestRequestHandler()) using (var client = new RingMasterClient(requestHandler)) { string path = this.GetRandomString(); string retrievalCondition = this.GetRandomString(); var watcher = new TestWatcher(this.GetRandomInt()); IReadOnlyList <string> expectedChildren = new string[] { this.GetRandomString(), this.GetRandomString() }; requestHandler.Implementation = request => { Assert.IsTrue(request is RequestGetChildren); var getChildrenRequest = (RequestGetChildren)request; Assert.AreEqual(path, getChildrenRequest.Path); Assert.AreEqual(watcher.Id, getChildrenRequest.Watcher.Id); return(new RequestResponse() { ResultCode = (int)RingMasterException.Code.Ok, Content = expectedChildren }); }; client.SetWatcher(watcher); var children = client.GetChildren(path, watch: true, retrievalCondition: retrievalCondition).Result; Assert.AreEqual(expectedChildren.Count, children.Count); for (int i = 0; i < expectedChildren.Count; i++) { Assert.AreEqual(expectedChildren[i], children[i]); } } }
/// <summary> /// Thread to mock a NSM / LNM which is publishing VNET data /// </summary> /// <param name="cancel">Cancellation token</param> /// <param name="threadId">Thread sequence number</param> /// <param name="operationCount">Object to store operation statistics</param> private void MockLnmThread(CancellationToken cancel, int threadId, OperationCount operationCount) { using (var client = new RingMasterClient(serverAddress, null, null, 10000)) { var rnd = new Random(); while (!cancel.IsCancellationRequested) { Task.Run(async() => { try { var vnet = $"/mud/vnets/{CreateSpanningVnetId(threadId)}"; var stat = await client.Exists(vnet, null, true); var ops = new List <Op>(); if (stat == null) { ops.Add(Op.Create($"{vnet}/mappings/v4ca", null, null, CreateMode.PersistentAllowPathCreation)); ops.Add(Op.Create($"{vnet}/lnms/thread-{threadId}", null, null, CreateMode.PersistentAllowPathCreation)); await client.Multi(ops, true); ops.Clear(); operationCount.AddCreate(2); } var mappingCount = rnd.Next(1, 1024 * 8); for (int i = 0; i < mappingCount; i++) { ops.Add(Op.Create($"{vnet}/mappings/v4ca/{i}", null, null, CreateMode.PersistentAllowPathCreation)); operationCount.AddCreate(1); } await client.Multi(ops, true); ops.Clear(); for (int i = 0; i < mappingCount; i++) { var data = new byte[rnd.Next(minPayloadSize, maxPayloadSize)]; ops.Add(Op.SetData($"{vnet}/mappings/v4ca/{i}", data, -1)); operationCount.AddSet(1); operationCount.AddData(data.Length); } await client.Multi(ops, true); ops.Clear(); } catch (Exception ex) { operationCount.IncrementFailure(); // Ignore and keep going log($"FAIL in {threadId}: {ex.Message}"); } }).GetAwaiter().GetResult(); } } }
/// <summary> /// Send a poison pill to the given ringmaster affecting the given path. /// </summary> /// <param name="ringMaster">Ring master to which the poison pill must be sent</param> /// <param name="path">Path affected by the poison pill</param> /// <returns>A Task that tracks execution of this method</returns> private static async Task SendPoisonPillCommand(RingMasterClient ringMaster, string path) { await ringMaster.SetAuth(new Id(AuthSchemes.Digest, "commander")); string poisonPillCommand = string.Format("break:{0}", path); byte[] data = Encoding.UTF8.GetBytes(poisonPillCommand); await ringMaster.Create("$/poisonpill", data, null, CreateMode.Persistent); }
private void ConnectPerformanceTest(ConfigurationSection config, CancellationToken cancellationToken) { try { var instrumentation = new ConnectPerformanceInstrumentation(this.MetricsFactory); var random = new Random(); string connectionString = config.GetStringValue("TargetConnectionString"); connectionString = Helpers.GetServerAddressIfNotProvided(connectionString); IPEndPoint[] endpoints = SecureTransport.ParseConnectionString(connectionString); string testPath = config.GetStringValue("TestPath"); int numConnections = config.GetIntValue("NumberOfConnections"); int maxConcurrentRequests = config.GetIntValue("MaxConcurrentRequests"); int minConnectionLifetimeSeconds = config.GetIntValue("MinConnectionLifetimeSeconds"); int maxConnectionLifetimeSeconds = config.GetIntValue("MaxConnectionLifetimeSeconds"); Func <IRingMasterRequestHandler> createConnection = () => { var connectionConfiguration = new SecureTransport.Configuration { UseSecureConnection = false, CommunicationProtocolVersion = RingMasterCommunicationProtocol.MaximumSupportedVersion, MaxConnectionLifespan = TimeSpan.FromSeconds(random.Next(minConnectionLifetimeSeconds, maxConnectionLifetimeSeconds)) }; var protocol = new RingMasterCommunicationProtocol(); var transport = new SecureTransport(connectionConfiguration, instrumentation, cancellationToken); var client = new RingMasterClient(protocol, transport); transport.StartClient(endpoints); ConnectionStressServiceEventSource.Log.CreateConnection( connectionConfiguration.UseSecureConnection, connectionConfiguration.CommunicationProtocolVersion, (long)connectionConfiguration.MaxConnectionLifespan.TotalSeconds); client.Exists("/", watcher: null).Wait(); return((IRingMasterRequestHandler)client); }; using (var connectPerformanceTest = new ConnectPerformance(instrumentation, maxConcurrentRequests, cancellationToken)) { ConnectionStressServiceEventSource.Log.ConnectPerformanceTestStarted(testPath, numConnections, minConnectionLifetimeSeconds, maxConnectionLifetimeSeconds); connectPerformanceTest.EstablishConnections(createConnection, numConnections); connectPerformanceTest.QueueRequests(testPath); } ConnectionStressServiceEventSource.Log.ConnectPerformanceTestCompleted(); } catch (Exception ex) { ConnectionStressServiceEventSource.Log.ConnectPerformanceTestFailed(ex.ToString()); } }
private static async Task CreateFlatTree(RingMasterClient ringMaster, string path, int maxNodes, int[] numCreated) { await ringMaster.Create(path, null, null, CreateMode.PersistentAllowPathCreation, throwIfNodeExists : false); while (numCreated[0] < maxNodes) { await ringMaster.Create($"{path}/{Guid.NewGuid()}", null, null, CreateMode.PersistentAllowPathCreation, throwIfNodeExists : false); numCreated[0]++; } }
private async Task DeleteChild(string root, int childCount) { using (var client = new RingMasterClient(serverAddress, null, null, 10000)) { for (int count = 0; count < childCount; count++) { var path = $"/{root}/{count}"; await client.Delete(path, -1, DeleteMode.SuccessEvenIfNodeDoesntExist); } } }
public void TestDefaultconfiguration() { var configuration = new RingMasterClient.Configuration(); var protocol = new RingMasterCommunicationProtocol(); using (var clientTransport = new SimpleTransport()) using (var ringMaster = new RingMasterClient(protocol, clientTransport)) { Assert.AreEqual((int)configuration.DefaultTimeout.TotalMilliseconds, ringMaster.Timeout); } }
/// <summary> /// Work load for testing Create method /// </summary> private static void CreateNodeThread(CancellationToken cancellationToken) { const string rootNodeName = "UpgradeTest"; RingMasterClient client = null; while (!cancellationToken.IsCancellationRequested) { if (client == null) { client = new RingMasterClient( connectionString: serverAddress, clientCerts: null, serverCerts: null, requestTimeout: requestTimeout, watcher: null); } Parallel.For( 0, CreateBatchCount, new ParallelOptions { MaxDegreeOfParallelism = Environment.ProcessorCount * 2, }, (i, loopState) => { var path = $"/{rootNodeName}/{totalDataCount}"; var data = Enumerable.Range(0, NodeDataLength).Select(x => (byte)(x + i)).ToArray(); try { client.Create( path, data, null, CreateMode.PersistentAllowPathCreation | CreateMode.SuccessEvenIfNodeExistsFlag) .GetAwaiter().GetResult(); client.GetData(path, false).GetAwaiter().GetResult(); Interlocked.Increment(ref totalDataCount); lastOpTimestamp = clock.Elapsed; } catch (Exception ex) { Interlocked.Increment(ref totalFailures); client = null; log($"Exception: {ex.Message}"); loopState.Stop(); } }); } }
public void TestConstructorWithConnectionStringNoCancellationToken() { var configuration = new RingMasterClient.Configuration(); configuration.DefaultTimeout = Timeout.InfiniteTimeSpan; configuration.HeartBeatInterval = Timeout.InfiniteTimeSpan; configuration.RequestQueueLength = int.MaxValue; configuration.BufferSize = int.MaxValue; var instrumentation = new RingMasterClientInstrumentation(); using (var client = new RingMasterClient("127.0.0.1:0", configuration, instrumentation)) { } }
private void ConnectPerformanceTest(SecureTransport.Configuration configuration, IPEndPoint[] endpoints, int numConnections) { var instrumentation = new ConnectPerformanceInstrumentation(); var random = new Random(); int minConnectionLifetimeSeconds = int.Parse(appSettings["ConnectPerformance.MinConnectionLifetimeSeconds"]); int maxConnectionLifetimeSeconds = int.Parse(appSettings["ConnectPerformance.MaxConnectionLifetimeSeconds"]); Func <IRingMasterRequestHandler> createConnection = () => { var connectionConfiguration = new SecureTransport.Configuration { UseSecureConnection = configuration.UseSecureConnection, ClientCertificates = configuration.ClientCertificates, ServerCertificates = configuration.ServerCertificates, CommunicationProtocolVersion = configuration.CommunicationProtocolVersion, MaxConnectionLifespan = TimeSpan.FromSeconds(random.Next(minConnectionLifetimeSeconds, maxConnectionLifetimeSeconds)), }; var protocol = new RingMasterCommunicationProtocol(); var transport = new SecureTransport(connectionConfiguration, instrumentation, CancellationToken.None); var client = new RingMasterClient(protocol, transport); transport.StartClient(endpoints); client.Exists("/", watcher: null).Wait(); return((IRingMasterRequestHandler)client); }; using (var connectPerformanceTest = new ConnectPerformance(instrumentation, this.MaxConcurrency, CancellationToken.None)) { Trace.TraceInformation($"Connect performance test numConnections={numConnections}, path={this.TestPath}, minConnectionLifetimeSeconds={minConnectionLifetimeSeconds}, maxConnectionLifetimeSeconds={maxConnectionLifetimeSeconds}"); connectPerformanceTest.EstablishConnections(createConnection, numConnections); var task = Task.Run(() => connectPerformanceTest.QueueRequests(this.TestPath)); long lastSuccessCount = 0; var timer = Stopwatch.StartNew(); while (!task.Wait(5000)) { timer.Stop(); long rate = (long)((instrumentation.Success - lastSuccessCount) * 1000) / timer.ElapsedMilliseconds; Trace.TraceInformation($"Connections created={instrumentation.ConnectionCreatedCount}, closed={instrumentation.ConnectionClosedCount}, requestSuccess={instrumentation.Success}, requestFailure={instrumentation.Failure}, rate={rate}"); timer.Restart(); lastSuccessCount = instrumentation.Success; } } }
public void TestConstructorWithConnectionStringAndCertificates() { var clientCertificates = GetLocalCertificates(1); var serverCertificates = GetLocalCertificates(1); try { var watcher = new TestWatcher(0); using (var client = new RingMasterClient("127.0.0.1:0", clientCertificates, serverCertificates, 0, watcher)) { client.Sync("/").Wait(); } } catch (Exception) { } }
public void TestConstructorWithConnectionStringAndThumbprints() { var clientCertificateThumbprints = GetLocalCertificates(1).Select(c => c.GetCertHashString()).ToArray(); var serverCertificateThumbprints = GetLocalCertificates(1).Select(c => c.GetCertHashString()).ToArray(); try { var watcher = new TestWatcher(0); using (var client = new RingMasterClient("127.0.0.1:0", clientCertificateThumbprints, serverCertificateThumbprints, 0, watcher)) { client.Sync("/").Wait(); } } catch (Exception) { } }
public void TestNullServerSpec() { var configuration = new RingMasterClient.Configuration(); var instrumentation = new RingMasterClientInstrumentation(); try { using (var clientTransport = new SimpleTransport()) using (var ringMaster = new RingMasterClient((RingMasterClient.ServerSpec)null, configuration, instrumentation, CancellationToken.None)) { Assert.Fail("ArgumentNullException should have been thrown"); } } catch (ArgumentNullException) { } }
public void TestCreateSingleThread() { using (var cancellationSource = new CancellationTokenSource()) { var cancel = cancellationSource.Token; using (var client = new RingMasterClient(serverAddress, null, null, 10000)) { var rnd = new Random(); var createCount = 0; var dataSize = 0; Task.Run(async() => { while (!cancel.IsCancellationRequested) { var data = new byte[rnd.Next(minPayloadSize, maxPayloadSize)]; var path = await client.Create($"/Perf/{createCount}", data, null, CreateMode.PersistentAllowPathCreation); Assert.AreNotEqual(null, path); Interlocked.Increment(ref createCount); Interlocked.Add(ref dataSize, data.Length); } }); Task.Run(async() => { var lastCount = createCount; while (!cancel.IsCancellationRequested) { await Task.Delay(1000); var delta = createCount - lastCount; lastCount = createCount; log($"{DateTime.Now} createCount={createCount} +{delta} dataSize={dataSize}"); } }); Thread.Sleep(10 * 1000); cancellationSource.Cancel(); log($"CreateCount = {createCount}"); } } }
/// <summary> /// Set the SSL configuration. /// </summary> /// <param name="ssl">SslWrapping object</param> public void SetSsl(SslWrapping ssl) { if (ssl != null) { this.transportConfiguration.UseSecureConnection = true; this.transportConfiguration.Identities = ssl.Identities; this.transportConfiguration.MustCheckCertificateRevocation = ssl.MustCheckCertificateRevocation; this.transportConfiguration.MustCheckCertificateTrustChain = ssl.MustCheckCertificateTrustChain; } else { this.transportConfiguration.UseSecureConnection = false; } this.client?.Close(); this.client?.Dispose(); this.client = null; }
public void TestTimeoutConfiguration() { int timespanInMilliseconds = 4536; var configuration = new RingMasterClient.Configuration() { DefaultTimeout = TimeSpan.FromMilliseconds(timespanInMilliseconds) }; var protocol = new RingMasterCommunicationProtocol(); using (var clientTransport = new SimpleTransport()) using (var ringMaster = new RingMasterClient(configuration, null, protocol, clientTransport, CancellationToken.None)) { Assert.AreEqual(timespanInMilliseconds, ringMaster.Timeout); ringMaster.Timeout = 10000; Assert.AreEqual(10000, ringMaster.Timeout); } }
public void TestBatch() { using (var requestHandler = new TestRequestHandler()) using (var client = new RingMasterClient(requestHandler)) { string path = this.GetRandomString(); var version = this.GetRandomInt(); var operations = new List <Op>(); operations.Add(Op.Delete(path, version, recursive: false)); var expectedResults = new List <OpResult>(); expectedResults.Add(new OpResult.DeleteResult()); requestHandler.Implementation = request => { Assert.IsTrue(request is RequestBatch); var batchRequest = (RequestBatch)request; Assert.IsTrue(batchRequest.CompleteSynchronously); Assert.AreEqual(operations.Count, batchRequest.Requests.Count); Assert.IsTrue(batchRequest.Requests[0] is RequestDelete); return(new RequestResponse() { ResultCode = (int)RingMasterException.Code.Ok, Content = expectedResults }); }; var results = client.Batch(operations, mustCompleteSynchronously: true).Result; Assert.AreEqual(results.Count, expectedResults.Count); Assert.IsTrue(results[0] is OpResult.DeleteResult); try { client.Batch(null, mustCompleteSynchronously: false).Wait(); Assert.Fail("Batch call must have thrown ArgumentNullException"); } catch (ArgumentException) { } } }
/// <summary> /// Wait until a stable connection can be established with the given ringmaster. /// </summary> /// <param name="ringMaster">RingMaster client</param> /// <param name="maxAttempts">Maximum number of attempts</param> /// <returns>A Task that resolves to <c>true</c> if the connection was successful</returns> private static async Task <bool> WaitForStableConnection(RingMasterClient ringMaster, int maxAttempts) { for (int retryCount = 0; retryCount < maxAttempts; retryCount++) { try { await ringMaster.Exists("/", watcher : null); return(true); } catch (Exception ex) { Trace.TraceError("WaitForStableConnection. exception={0}, retryCount={1}, maxAttempts={2}", ex.Message, retryCount, maxAttempts); } await Task.Delay(1000); } return(false); }
public void TestEmptyEndpoints() { var serverSpec = new RingMasterClient.ServerSpec(); var configuration = new RingMasterClient.Configuration(); var instrumentation = new RingMasterClientInstrumentation(); try { serverSpec.Endpoints = new IPEndPoint[0]; serverSpec.UseSecureConnection = false; using (var clientTransport = new SimpleTransport()) using (var ringMaster = new RingMasterClient(serverSpec, configuration, instrumentation, CancellationToken.None)) { Assert.Fail("ArgumentException should have been thrown"); } } catch (ArgumentException) { } }