/// <summary> /// Serialize <see cref="RequestGetChildren"/>. /// </summary> /// <param name="request">Request to serialize</param> private void SerializeRequestGetChildren(RequestGetChildren request) { this.SerializeWatcher(request.Watcher); bool hasValue = request.RetrievalCondition != null; this.binaryWriter.Write((bool)hasValue); if (hasValue) { this.binaryWriter.Write((string)request.RetrievalCondition); } }
/// <summary> /// Queue GetChildren requests. /// </summary> /// <param name="ringMaster">RingMaster client</param> /// <param name="rootPath">Path to enumerate</param> /// <param name="maxChildren">Maximum number of children to retrieve</param> public void QueueRequests(IRingMasterRequestHandler ringMaster, string rootPath, int maxChildren) { if (ringMaster == null) { throw new ArgumentNullException(nameof(ringMaster)); } var random = new RandomGenerator(); ulong requestId = 0; Trace.TraceInformation($"Queue GetChildren: path={rootPath}"); while (!this.cancellationToken.IsCancellationRequested) { string startingChildName = random.GetRandomName(this.MinNodeNameLength, this.MaxNodeNameLength); var getChildrenRequest = new RequestGetChildren(rootPath, watcher: null, retrievalCondition: $">:{maxChildren}:{startingChildName}", uid: requestId++); this.semaphore.Wait(); var timer = Stopwatch.StartNew(); ringMaster.Request(getChildrenRequest).ContinueWith(responseTask => { this.semaphore.Release(); timer.Stop(); try { RequestResponse response = responseTask.Result; if (response.ResultCode == (int)RingMasterException.Code.Ok) { var children = (IReadOnlyList <string>)response.Content; this.instrumentation?.GetChildrenSucceeded(rootPath, children.Count, timer.Elapsed); } else { this.instrumentation?.GetChildrenFailed(rootPath); } } catch (Exception) { this.instrumentation?.GetChildrenFailed(rootPath); } }); } }
/// <summary> /// Deserialize <see cref="IZooKeeperRequest"/> /// </summary> /// <param name="xid">the callid</param> /// <param name="type">type of the call</param> /// <param name="sessionState">The PerSession State</param> /// <param name="ringMasterRequest">The ring master request.</param> /// <exception cref="System.ArgumentException">unknown type + type</exception> /// <returns>The Zookeeper Request</returns> private IZooKeeperRequest DeserializeZooKeeperRequest(int xid, ZooKeeperRequestType type, ZkprPerSessionState sessionState, out IRingMasterRequest ringMasterRequest) { ringMasterRequest = null; switch (type) { case ZooKeeperRequestType.Notification: // "0" for Createing a session ringMasterRequest = null; return(this.DeserializeNotification(xid)); case ZooKeeperRequestType.CreateSession: ZkprProtocolMessages.CreateSession cs = this.DeserializeCreateSession(); ringMasterRequest = new RequestInit((ulong)cs.SessionId, cs.IsNullPassword ? string.Empty : cs.Password); sessionState.ConnectRecieved = true; return(cs); case ZooKeeperRequestType.Exists: ZkprProtocolMessages.Exists ex = this.DeserializeExists(xid); ringMasterRequest = new RequestExists(ex.Path, ex.Watch == false ? null : new Watcher((ulong)xid, WatcherKind.OneUse)); return(ex); case ZooKeeperRequestType.GetChildren: ZkprProtocolMessages.GetChildren gc = this.DeserializeGetChildren(xid); ringMasterRequest = new RequestGetChildren(gc.Path, gc.Watch == false ? null : new Watcher((ulong)xid, WatcherKind.OneUse), null); return(gc); case ZooKeeperRequestType.GetChildren2: ZkprProtocolMessages.GetChildren2 gc2 = this.DeserializeGetChildren2(xid); ringMasterRequest = new RequestGetChildren(gc2.Path, gc2.Watch == false ? null : new Watcher((ulong)xid, WatcherKind.OneUse), null); return(gc2); case ZooKeeperRequestType.GetData: ZkprProtocolMessages.GetData gd = this.DeserializeGetData(xid); ringMasterRequest = new RequestGetData(gd.Path, RequestGetData.GetDataOptions.None, gd.Watch == false ? null : new Watcher((ulong)xid, WatcherKind.OneUse)); return(gd); case ZooKeeperRequestType.Create: ZkprProtocolMessages.Create cr = this.DeserializeCreate(xid); IReadOnlyList <Acl> acls = this.TranslateZkprAclListToRMAclList(cr.Acls); CreateMode cm = this.TranslateZkprCreatFlagsToRmCreateMode(cr.Flags); ringMasterRequest = new RequestCreate(cr.Path, cr.Data, acls, cm); return(cr); case ZooKeeperRequestType.Create2: ZkprProtocolMessages.Create2 cr2 = this.DeserializeCreate2(xid); IReadOnlyList <Acl> acls2 = this.TranslateZkprAclListToRMAclList(cr2.Acls); CreateMode cm2 = this.TranslateZkprCreatFlagsToRmCreateMode(cr2.Flags); ringMasterRequest = new RequestCreate(cr2.Path, cr2.Data, acls2, cm2); return(cr2); case ZooKeeperRequestType.SetData: ZkprProtocolMessages.SetData sd = this.DeserializeSetData(xid); ringMasterRequest = new RequestSetData(sd.Path, sd.Data, sd.Version); return(sd); case ZooKeeperRequestType.Delete: ZkprProtocolMessages.Delete dl = this.DeserializeDelete(xid); ringMasterRequest = new RequestDelete(dl.Path, dl.Version, false); return(dl); case ZooKeeperRequestType.Ping: ringMasterRequest = null; return(this.DeserializePing(xid)); case ZooKeeperRequestType.CloseSession: ringMasterRequest = null; sessionState.ConnectRecieved = false; // Renegotiate the CreateSession return(this.DeserializeCloseSession(xid)); case ZooKeeperRequestType.GetACL: ZkprProtocolMessages.GetACL ga = this.DeserializeGetACL(xid); ringMasterRequest = new RequestGetAcl(ga.Path, null); return(ga); case ZooKeeperRequestType.SetACL: ZkprProtocolMessages.SetACL sa = this.DeserializeSetACL(xid); IReadOnlyList <Acl> sa_acls = this.TranslateZkprAclListToRMAclList(sa.Acls); ringMasterRequest = new RequestSetAcl(sa.Path, sa_acls, sa.Version); return(sa); case ZooKeeperRequestType.Multi: ZkprProtocolMessages.Multi mu = this.DeserializeMulti(xid); IReadOnlyList <Op> rmOps = this.TranslateZkprOpsListToRmOpsList(mu.Ops); ringMasterRequest = new RequestMulti(rmOps, false); return(mu); case ZooKeeperRequestType.Auth: ZkprProtocolMessages.Auth au = this.DeserializeAuth(xid); ringMasterRequest = new RequestSetAuth(au.RmAuthId); return(au); case ZooKeeperRequestType.Check: case ZooKeeperRequestType.Sync: case ZooKeeperRequestType.Reconfig: case ZooKeeperRequestType.SetWatches: case ZooKeeperRequestType.RemoveWatches: case ZooKeeperRequestType.CreateContainer: case ZooKeeperRequestType.DeleteContainer: case ZooKeeperRequestType.Sasl: case ZooKeeperRequestType.Error: default: break; } return(null); }
/// <summary> /// Processes the request in regards to the given cache object. /// </summary> /// <param name="cache">The cache object to use.</param> /// <param name="req">The request to process.</param> /// <returns><c>a response</c> if the processing was completed, <c>null</c> otherwise.</returns> private async Task <RequestResponse> ProcessCacheRequest(IRingMasterClientCache cache, IRingMasterRequest req) { if (cache != null && req != null) { RequestResponse cachedResponse = this.GetCachedResponse(cache, req); if (cachedResponse != null) { return(cachedResponse); } switch (req.RequestType) { case RingMasterRequestType.GetData: { RequestResponse resp = await this.baseHandler.Request(req); string prefix = this.cachePrefix; if (prefix != null) { cache.SetInfo(prefix, req.Path, CachedKind.NodeData | CachedKind.NodeStats, new PrefixedClientCache.DataEntry() { Data = (byte[])resp.Content, Stat = resp.Stat }); } return(resp); } case RingMasterRequestType.GetChildren: { RequestResponse resp = await this.baseHandler.Request(req); string prefix = this.cachePrefix; if (prefix != null) { RequestGetChildren gchil = req as RequestGetChildren; if (string.IsNullOrEmpty(gchil.RetrievalCondition)) { cache.SetInfo(prefix, req.Path, CachedKind.NodeChildren | CachedKind.NodeStats, new PrefixedClientCache.DataEntry() { Children = (IReadOnlyList <string>)resp.Content, Stat = resp.Stat }); } } return(resp); } case RingMasterRequestType.GetAcl: { RequestResponse resp = await this.baseHandler.Request(req); string prefix = this.cachePrefix; if (prefix != null) { cache.SetInfo(prefix, req.Path, CachedKind.NodeAcls | CachedKind.NodeStats, new PrefixedClientCache.DataEntry() { Acls = (IReadOnlyList <Acl>)resp.Content, Stat = resp.Stat }); } return(resp); } case RingMasterRequestType.Exists: { RequestResponse resp = await this.baseHandler.Request(req); string prefix = this.cachePrefix; if (prefix != null) { cache.SetInfo(prefix, req.Path, CachedKind.NodeStats, new PrefixedClientCache.DataEntry() { Stat = resp.Stat }); } return(resp); } } } return(await this.baseHandler.Request(req)); }