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)
{
}
}
