public void TestRequestUid()
{
var request1 = new RequestCreate(path: "/", data: null, acl: null, createMode: CreateMode.Persistent);
var request2 = new RequestExists(path: "/", watcher: null);
var batch1 = new RequestMulti(
new List <Op>
{
Op.Check("/", 1),
Op.Delete("/a", -1)
},
completeSynchronously: false);
var batch2 = new RequestMulti(
new List <Op>
{
Op.GetChildren("/"),
Op.Delete("/a", -1)
},
completeSynchronously: true);
Assert.IsTrue(request2.Uid > request1.Uid);
Assert.IsTrue(batch1.Requests[0].Uid > request2.Uid);
Assert.IsTrue(batch1.Requests[1].Uid > batch1.Requests[0].Uid);
Assert.IsTrue(batch1.Uid > batch1.Requests[1].Uid);
Assert.IsTrue(batch2.Uid > batch1.Uid);
}
private IReadOnlyList <Op> TranslateZkprOpsListToRmOpsList(IReadOnlyList <IZooKeeperRequest> zkprOps)
{
List <Op> rmOps = new List <Op>();
foreach (IZooKeeperRequest zkReq in zkprOps)
{
switch (zkReq.RequestType)
{
case ZooKeeperRequestType.Create:
ZkprProtocolMessages.Create zkCreate = zkReq as ZkprProtocolMessages.Create;
IReadOnlyList <Acl> acls = this.TranslateZkprAclListToRMAclList(zkCreate.Acls);
CreateMode cm = this.TranslateZkprCreatFlagsToRmCreateMode(zkCreate.Flags);
rmOps.Add(Op.Create(zkCreate.Path, zkCreate.Data, acls, cm));
break;
case ZooKeeperRequestType.Delete:
ZkprProtocolMessages.Delete zkDelete = zkReq as ZkprProtocolMessages.Delete;
rmOps.Add(Op.Delete(zkDelete.Path, zkDelete.Version, false));
break;
case ZooKeeperRequestType.SetData:
ZkprProtocolMessages.SetData zkSetData = zkReq as ZkprProtocolMessages.SetData;
rmOps.Add(Op.SetData(zkSetData.Path, zkSetData.Data, zkSetData.Version));
break;
case ZooKeeperRequestType.Check:
ZkprProtocolMessages.Check zkCheck = zkReq as ZkprProtocolMessages.Check;
rmOps.Add(Op.Check(zkCheck.Path, zkCheck.Version));
break;
}
}
return(rmOps);
}
public void TestRequestInMultiReturnCorrectly()
{
TestRequestInMultiReturnCorrectlyAsync().GetAwaiter().GetResult();
async Task TestRequestInMultiReturnCorrectlyAsync()
{
const string RootName = nameof(this.TestRequestInMultiReturnCorrectly);
using (var rm = new RingMasterClient(serverAddress, null, null, 10000))
{
await rm.Create($"/{RootName}/child1", null, null, CreateMode.PersistentAllowPathCreation);
await rm.Create($"/{RootName}/child2", null, null, CreateMode.PersistentAllowPathCreation);
await rm.Create($"/{RootName}/child3", null, null, CreateMode.PersistentAllowPathCreation);
var ops = new List <Op>
{
Op.Check($"/{RootName}", -1),
Op.GetChildren($"/{RootName}"),
};
var multiResult = await rm.Multi(ops);
Assert.AreEqual(multiResult.Count, ops.Count);
var checkResult = multiResult[0] as OpResult.CheckResult;
var getChildrenResult = multiResult[1] as OpResult.GetChildrenResult;
Assert.AreEqual(3, checkResult.Stat.NumChildren);
Assert.AreEqual(RingMasterException.Code.Ok, getChildrenResult.ErrCode);
Assert.AreEqual(3, getChildrenResult.Children.Count);
Assert.AreEqual(3, getChildrenResult.Stat.NumChildren);
}
}
}
public void QueueBatches(IRingMasterRequestHandler ringMaster, int batchLength)
{
if (ringMaster == null)
{
throw new ArgumentNullException(nameof(ringMaster));
}
ulong batchId = 0;
var random = new RandomGenerator();
Trace.TraceInformation($"Queue Exists Batches");
while (!this.cancellationToken.IsCancellationRequested)
{
var operations = new Op[batchLength];
for (int i = 0; i < batchLength; i++)
{
var index = random.GetRandomInt(0, this.nodeList.Count);
var nodePath = this.nodeList[index];
operations[i] = Op.Check(nodePath, -1);
}
var batchRequest = new RequestBatch(operations, completeSynchronously: false, uid: batchId++);
this.semaphore.Wait();
var timer = Stopwatch.StartNew();
ringMaster.Request(batchRequest).ContinueWith(responseTask =>
{
try
{
this.semaphore.Release();
timer.Stop();
int successCount = 0;
int failureCount = 0;
RequestResponse response = responseTask.Result;
if (response.ResultCode == (int)RingMasterException.Code.Ok)
{
var results = (IReadOnlyList <OpResult>)response.Content;
if (results != null)
{
foreach (var result in results)
{
if (result.ErrCode == RingMasterException.Code.Ok)
{
successCount++;
}
else
{
failureCount++;
}
}
}
this.instrumentation?.BatchProcessed(timer.Elapsed, batchRequest.Requests.Count, successCount, failureCount);
}
else
{
this.instrumentation?.BatchFailed(batchRequest.Requests.Count);
}
}
catch (Exception)
{
this.instrumentation?.BatchFailed(batchRequest.Requests.Count);
}
});
}
}
/// <summary>
/// Work load for adding / deleting and checking the number of children in VNET nodes
/// </summary>
/// <param name="id">Task sequence number to avoid write conflict</param>
/// <param name="cancellationToken">Cancellation token to stop the operation</param>
/// <returns>Async task to indicate the completion of operation</returns>
private static async Task CheckNodeThread(int id, CancellationToken cancellationToken)
{
var lastMzxids = new long[VnetCount];
RingMasterClient client = null;
var createMode = CreateMode.PersistentAllowPathCreation | CreateMode.SuccessEvenIfNodeExistsFlag;
while (!cancellationToken.IsCancellationRequested)
{
if (client == null)
{
client = new RingMasterClient(
connectionString: serverAddress,
clientCerts: null,
serverCerts: null,
requestTimeout: requestTimeout,
watcher: null);
}
for (int vnetId = 0; vnetId < VnetCount; vnetId++)
{
try
{
var parent = $"/vnets-{vnetId}/lnms";
// Create some children
await client.Multi(
Enumerable.Range(0, ChildrenCount).Select(n => Op.Create($"{parent}/node-{id}-{n}", null, null, createMode)).ToList(),
true);
var result = await client.Multi(new Op[] { Op.Check(parent, -1), Op.GetChildren(parent), }, true);
// Check number of children is correct -- it must be more than the number of children being created
var stat = ((OpResult.CheckResult)result[0]).Stat;
var children = ((OpResult.GetChildrenResult)result[1]).Children;
if (stat.NumChildren < MinNodeCount + ChildrenCount)
{
log($"Task {id}: wrong stat {stat.NumChildren} < {MinNodeCount + ChildrenCount}");
totalFailures++;
}
if (children.Count < MinNodeCount + ChildrenCount)
{
log($"Task {id}: wrong children {children.Count} < {MinNodeCount + ChildrenCount}");
totalFailures++;
}
if (stat.NumChildren != children.Count)
{
log($"Task {id}: stat {stat.NumChildren} inconsistent with children {children.Count}");
totalFailures++;
}
if (stat.NumChildren <= 0)
{
log($"Task {id}: Stat at {parent} is wrong: {stat}");
totalFailures++;
}
// Delete children being added -- the minimal number of children should be still there
await client.Multi(
Enumerable.Range(0, ChildrenCount).Select(n => Op.Delete($"{parent}/node-{id}-{n}", -1, false)).ToList(),
true);
result = await client.Multi(new Op[] { Op.Check(parent, -1), Op.GetChildren(parent), }, true);
stat = ((OpResult.CheckResult)result[0]).Stat;
children = ((OpResult.GetChildrenResult)result[1]).Children;
if (stat.NumChildren < MinNodeCount)
{
log($"Task {id}: wrong stat {stat.NumChildren} < {MinNodeCount}");
totalFailures++;
}
if (children.Count < MinNodeCount)
{
log($"Task {id}: wrong children {children.Count} < {MinNodeCount}");
totalFailures++;
}
if (stat.NumChildren != children.Count)
{
log($"Task {id}: stat {stat.NumChildren} inconsistent with children {children.Count}");
totalFailures++;
}
if (stat.NumChildren <= 0)
{
log($"Task {id}: Stat at {parent} is wrong: {stat}");
totalFailures++;
}
totalOperationCount++;
}
catch (Exception ex)
{
client = null;
log($"Task {id}: Exception: {ex.Message}");
break;
}
}
}
}
public void TestIsReadOnly()
{
Assert.IsTrue(new RequestCheck(path: "/", version: 1).IsReadOnly());
Assert.IsFalse(new RequestCreate(path: "/", data: null, acl: null, createMode: CreateMode.Persistent).IsReadOnly());
Assert.IsFalse(new RequestDelete(path: "/", version: 1, cascade: false).IsReadOnly());
Assert.IsTrue(new RequestExists(path: "/", watcher: null).IsReadOnly());
Assert.IsTrue(new RequestGetAcl(path: "/", stat: null).IsReadOnly());
Assert.IsTrue(new RequestGetChildren(path: "/", watcher: null, retrievalCondition: null).IsReadOnly());
Assert.IsTrue(new RequestGetData(path: "/", options: RequestGetData.GetDataOptions.None, watcher: null).IsReadOnly());
Assert.IsFalse(new RequestInit(sessionId: 0, sessionPwd: "abc", readOnlyInterfaceRequiresLocks: true, redirection: RequestInit.RedirectionPolicy.ServerDefault).IsReadOnly());
Assert.IsFalse(new RequestSetAcl(path: "/", acl: null, version: -1).IsReadOnly());
Assert.IsFalse(new RequestSetAuth(clientId: "abc").IsReadOnly());
Assert.IsFalse(new RequestSetData(path: "/", data: null, version: 1, dataCommand: false).IsReadOnly());
Assert.IsTrue(new RequestSync(path: "/").IsReadOnly());
Assert.IsTrue(new RequestGetSubtree(path: "/", retrievalCondition: null).IsReadOnly());
Assert.IsTrue(new RequestMulti(new IRingMasterRequest[0], completeSynchronously: false).IsReadOnly());
var readMulti = new RequestMulti(
new List <Op>
{
Op.Check("/", 1),
Op.GetData("/a", RequestGetData.GetDataOptions.None, Op.Check("/a", 1))
},
completeSynchronously: false);
Assert.IsTrue(readMulti.IsReadOnly());
var readWriteMulti = new RequestMulti(
new List <Op>
{
Op.Check("/a", 1),
Op.Create("/a/b", null, null, CreateMode.Ephemeral)
},
completeSynchronously: true);
Assert.IsFalse(readWriteMulti.IsReadOnly());
var nestedReadMulti = new RequestMulti(
new IRingMasterRequest[]
{
readMulti
},
completeSynchronously: false);
Assert.IsTrue(nestedReadMulti.IsReadOnly());
var nestedReadWriteMulti = new RequestMulti(
new IRingMasterRequest[]
{
readMulti,
readWriteMulti
},
completeSynchronously: true);
Assert.IsFalse(nestedReadWriteMulti.IsReadOnly());
Assert.IsTrue(new RequestBatch(new IRingMasterRequest[0], completeSynchronously: false).IsReadOnly());
var readBatch = new RequestBatch(
new List <Op>
{
Op.Check("/", 1),
Op.GetData("/a", RequestGetData.GetDataOptions.None, Op.Check("/a", 1))
},
completeSynchronously: false);
Assert.IsTrue(readBatch.IsReadOnly());
var readWriteBatch = new RequestBatch(
new List <Op>
{
Op.Check("/a", 1),
Op.Create("/a/b", null, null, CreateMode.Ephemeral)
},
completeSynchronously: false);
Assert.IsFalse(readWriteBatch.IsReadOnly());
var nestedReadBatch = new RequestBatch(
new IRingMasterRequest[]
{
readMulti,
readBatch
},
completeSynchronously: false);
Assert.IsTrue(nestedReadBatch.IsReadOnly());
var nestedReadWriteBatch = new RequestMulti(
new IRingMasterRequest[]
{
readBatch,
readWriteMulti
},
completeSynchronously: false);
Assert.IsFalse(nestedReadWriteBatch.IsReadOnly());
}
