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()); }