Ejemplo n.º 1
0
        private void SerializeResponseMulti(RequestResponse response, IZooKeeperRequest request)
        {
            this.SerializeReplyHeader(response.Stat == null ? 0L : response.Stat.Mzxid, response.ResultCode, request.Xid);
            List <OpResult> results = response.Content as List <OpResult>;

            foreach (OpResult or in results)
            {
                this.SerializeMultiHeader(this.TranslateRmOpResultTypeToZkOpType(or.ResultType), false, this.TranslateRingMasterResultCodeToZkprErrorCode((int)or.ErrCode));
                RequestResponse rr = OpResult.ToResponse(or);
                switch (or.ResultType)
                {
                case OpCode.Create:
                    this.binaryWriter.WriteString32BitPrefixLengthBE(rr.Content as string);
                    break;

                case OpCode.Delete:
                    break;

                case OpCode.SetData:
                    this.SerializeStat(rr.Stat);
                    break;

                case OpCode.Check:
                    break;
                }
            }

            this.SerializeMultiHeader(-1, true, -1);
        }
Ejemplo n.º 2
0
        /// <summary>
        /// Deserialize a <see cref="RequestCall"/>.
        /// </summary>
        /// <param name="sessionState">PerSession state</param>
        /// <returns>Deserialized <see cref="RequestCall"/></returns>
        public ProtocolRequestCall DeserializeRequest(ZkprPerSessionState sessionState)
        {
            int callId;
            ZooKeeperRequestType type = ZooKeeperRequestType.Notification;

            if (sessionState == null)
            {
                throw new ArgumentNullException("sessionState");
            }

            if (!sessionState.ConnectRecieved)
            {
                type   = ZooKeeperRequestType.CreateSession;
                callId = 0;
            }
            else
            {
                callId = this.binaryReader.ReadInt32BE();
                type   = (ZooKeeperRequestType)this.binaryReader.ReadInt32BE();
            }

            IRingMasterRequest ringMasterRequest;
            IZooKeeperRequest  zkprRequest = this.DeserializeZooKeeperRequest(callId, type, sessionState, out ringMasterRequest);

            return(new ProtocolRequestCall()
            {
                CallId = (ulong)callId,
                Request = ringMasterRequest,
                ProtocolRequest = zkprRequest,
            });
        }
Ejemplo n.º 3
0
        private void SerializeResponseGetChildren(RequestResponse response, IZooKeeperRequest request)
        {
            this.SerializeReplyHeader(response.Stat == null ? 0L : response.Stat.Mzxid, response.ResultCode, request.Xid);

            if (response.Content != null)
            {
                IEnumerable <string> children = response.Content as IEnumerable <string>;
                if (children.Any <string>())
                {
                    this.binaryWriter.WriteBE((int)children.Count <string>());

                    foreach (string c in children)
                    {
                        this.binaryWriter.WriteString32BitPrefixLengthBE(c);
                    }
                }
                else
                {
                    this.binaryWriter.WriteBE((int)-1);
                }

                if (request.RequestType == ZooKeeperRequestType.GetChildren2)
                {
                    this.SerializeStat(response.Stat);
                }
            }
            else
            {
                this.binaryWriter.WriteString32BitPrefixLengthBE(string.Empty);
            }
        }
Ejemplo n.º 4
0
        private void SerializeResponseCreateSession(RequestResponse response, IZooKeeperRequest request)
        {
            if (response.ResultCode == (int)Microsoft.Azure.Networking.Infrastructure.RingMaster.Data.RingMasterException.Code.Ok)
            {
                int protocolVersion = ((ZkprProtocolMessages.CreateSession)request).Version;
                this.binaryWriter.WriteBE(protocolVersion);
                this.binaryWriter.WriteBE(((ZkprProtocolMessages.CreateSession)request).Timeout);
                ulong sessionId;
                sessionId = (ulong)((ZkprProtocolMessages.CreateSession)request).SessionId;
                if (sessionId == 0)
                {
                    sessionId = Convert.ToUInt64(((string[])response.Content)[0]);
                }

                this.binaryWriter.WriteBE(sessionId);
                string sPassword;
                if (((ZkprProtocolMessages.CreateSession)request).IsNullPassword)
                {
                    sPassword = ((string[])response.Content)[1];
                }
                else
                {
                    sPassword = ((ZkprProtocolMessages.CreateSession)request).Password;
                }

                this.binaryWriter.WriteString32BitPrefixLengthBE(sPassword);
            }
            else
            {
                // Dont know what to do in case of error return error
            }
        }
Ejemplo n.º 5
0
 /// <summary>
 /// Serialize a <see cref="RequestResponse"/>.
 /// </summary>
 /// <param name="response">Response to serialize</param>
 /// <param name="version">Serialization protocol version to use</param>
 /// <param name="zkprRequest">The Zookeeper request</param>
 /// <returns>Serialized representation of the given response</returns>
 public byte[] SerializeResponse(RequestResponse response, uint version, IZooKeeperRequest zkprRequest)
 {
     using (var serializer = new ZkprSerializer(version))
     {
         serializer.SerializeResponse(response, zkprRequest);
         return(serializer.GetBytes());
     }
 }
Ejemplo n.º 6
0
        private void SerializeResponseExists(RequestResponse response, IZooKeeperRequest request)
        {
            Stat stat = (Stat)response.Content;

            this.SerializeReplyHeader(stat == null ? 0L : stat.Mzxid, response.ResultCode, request.Xid);

            this.SerializeStat(stat);
        }
Ejemplo n.º 7
0
        private void SerializeResponsePing(RequestResponse response, IZooKeeperRequest request)
        {
            Stat stat;

            stat = new Stat()
            {
                Czxid = -1
            };
            this.SerializeReplyHeader(stat.Mzxid, response.ResultCode, request.Xid);
        }
Ejemplo n.º 8
0
 private void SerializeResponseCreate(RequestResponse response, IZooKeeperRequest request)
 {
     this.SerializeReplyHeader(response.Stat == null ? 0L : response.Stat.Mzxid, response.ResultCode, request.Xid);
     if (((response.ResultCode == (int)RingMasterException.Code.Ok) || (response.ResultCode == (int)RingMasterException.Code.Nodeexists)) && (response.Content != null))
     {
         this.binaryWriter.WriteString32BitPrefixLengthBE(response.Content as string);
         if (request.RequestType == ZooKeeperRequestType.Create2)
         {
             this.SerializeStat(response.Stat);
         }
     }
     else
     {
         this.binaryWriter.WriteString32BitPrefixLengthBE(string.Empty);
     }
 }
Ejemplo n.º 9
0
        private void SerializeResponseGetACL(RequestResponse response, IZooKeeperRequest request)
        {
            this.SerializeReplyHeader(response.Stat == null ? 0L : response.Stat.Mzxid, response.ResultCode, request.Xid);
            IEnumerable <Acl>   theAcls  = response.Content as IEnumerable <Acl>;
            IReadOnlyList <Acl> zkprAcls = this.TranslateRingMasterAclListToZkprAclList(theAcls);

            if (zkprAcls == null)
            {
                zkprAcls = new List <Acl>();
            }

            // Write the count of Acls
            this.binaryWriter.WriteBE((int)zkprAcls.Count);
            foreach (Acl a in zkprAcls)
            {
                this.binaryWriter.WriteBE((int)a.Perms);
                this.binaryWriter.WriteString32BitPrefixLengthBE(a.Id.Scheme);
                this.binaryWriter.WriteString32BitPrefixLengthBE(a.Id.Identifier);
            }

            this.SerializeStat(response.Stat);
        }
Ejemplo n.º 10
0
        private RequestResponse ProcessRequest(IRingMasterRequest request, IZooKeeperRequest zkprRequest)
        {
            if (request == null)
            {
                throw new ArgumentNullException(nameof(request));
            }

            if (zkprRequest == null)
            {
                throw new ArgumentNullException(nameof(zkprRequest));
            }

            switch (request.RequestType)
            {
            case RingMasterRequestType.Init:
            {
                var             initRequest  = (Requests.RequestInit)request;
                RequestResponse initResponse = null;

                if (this.requestHandler == null)
                {
                    this.requestHandler = this.onInitSession(initRequest);
                    if (((zkprRequest as ZkprProtocolMessages.CreateSession).SessionId != 0) || (zkprRequest as ZkprProtocolMessages.CreateSession).IsNullPassword == false)
                    {
                        initResponse = new RequestResponse
                        {
                            ResultCode = (int)RingMasterException.Code.Authfailed,
                            Content    = new string[] { "0", string.Empty },
                        };
                    }
                }

                if (initResponse == null)
                {
                    initResponse = (this.requestHandler as CoreRequestHandler).InitResponse;
                }

                ZooKeeperServerEventSource.Log.ProcessSessionInit(this.Id, initResponse.ResultCode);
                return(initResponse);
            }

            case RingMasterRequestType.GetData:
            {
                var getDataRequest = (Requests.RequestGetData)request;
                getDataRequest.Watcher = this.MakeWatcher(getDataRequest.Watcher);
                break;
            }

            case RingMasterRequestType.GetChildren:
            {
                var getChildrenRequest = (Requests.RequestGetChildren)request;
                getChildrenRequest.Watcher = this.MakeWatcher(getChildrenRequest.Watcher);
                break;
            }

            case RingMasterRequestType.Exists:
            {
                var existsRequest = (Requests.RequestExists)request;
                existsRequest.Watcher = this.MakeWatcher(existsRequest.Watcher);
                break;
            }
            }

            if (this.server.Redirect != null)
            {
                RedirectSuggested redirect = this.server.Redirect();

                ZooKeeperServerEventSource.Log.RedirectionSuggested(this.Id, redirect?.SuggestedConnectionString);
                return(new RequestResponse()
                {
                    ResponsePath = request.Path,
                    ResultCode = (int)RingMasterException.Code.Sessionmoved,
                    Stat = default(Stat),
                    Content = redirect,
                });
            }

            if (this.requestHandler != null)
            {
                using (var completed = new AutoResetEvent(false))
                {
                    RequestResponse response = null;
                    this.requestHandler.RequestOverlapped(request, (r, e) =>
                    {
                        response = r;
                        completed.Set();
                    });

                    completed.WaitOne();
                    return(response);
                }
            }

            throw new InvalidOperationException("Session has not been initialized");
        }
Ejemplo n.º 11
0
        /// <summary>
        /// Serialize a <see cref="RequestResponse"/>.
        /// </summary>
        /// <param name="response">Response to serialize</param>
        /// <param name="zkprRequest">The Per call zookeeper request</param>
        public void SerializeResponse(RequestResponse response, IZooKeeperRequest zkprRequest)
        {
            if (response == null)
            {
                throw new ArgumentNullException("response");
            }

            if (zkprRequest == null)
            {
                throw new ArgumentNullException("zkprRequest");
            }

            switch (zkprRequest.RequestType)
            {
            case ZooKeeperRequestType.CreateSession:
                this.SerializeResponseCreateSession(response, zkprRequest);
                break;

            case ZooKeeperRequestType.GetChildren:
            case ZooKeeperRequestType.GetChildren2:
                this.SerializeResponseGetChildren(response, zkprRequest);
                break;

            case ZooKeeperRequestType.Create:
            case ZooKeeperRequestType.Create2:
                this.SerializeResponseCreate(response, zkprRequest);
                break;

            case ZooKeeperRequestType.Delete:
                this.SerializeResponseDelete(response, zkprRequest);
                break;

            case ZooKeeperRequestType.Exists:
                this.SerializeResponseExists(response, zkprRequest);
                break;

            case ZooKeeperRequestType.GetData:
                this.SerializeResponseGetData(response, zkprRequest);
                break;

            case ZooKeeperRequestType.SetData:
                this.SerializeResponseSetData(response, zkprRequest);
                break;

            case ZooKeeperRequestType.GetACL:
                this.SerializeResponseGetACL(response, zkprRequest);
                break;

            case ZooKeeperRequestType.SetACL:
                this.SerializeResponseSetACL(response, zkprRequest);
                break;

            case ZooKeeperRequestType.Multi:
                this.SerializeResponseMulti(response, zkprRequest);
                break;

            case ZooKeeperRequestType.Auth:
                this.SerializeResponseAuth(response, zkprRequest);
                break;

            case ZooKeeperRequestType.Sync:
                break;

            case ZooKeeperRequestType.Check:     // Apparently this is only supported in a multi?
                break;

            case ZooKeeperRequestType.Reconfig:
                break;

            case ZooKeeperRequestType.CheckWatches:
                break;

            case ZooKeeperRequestType.RemoveWatches:
                break;

            case ZooKeeperRequestType.CreateContainer:
                break;

            case ZooKeeperRequestType.DeleteContainer:
                break;

            case ZooKeeperRequestType.SetWatches:
                break;

            case ZooKeeperRequestType.Sasl:
                break;

            case ZooKeeperRequestType.Ping:
                this.SerializeResponsePing(response, zkprRequest);
                break;

            case ZooKeeperRequestType.Error:
            case ZooKeeperRequestType.CloseSession:
            case ZooKeeperRequestType.Notification:
            default:
                break;
            }

            return;
        }
Ejemplo n.º 12
0
 private void SerializeResponseSetData(RequestResponse response, IZooKeeperRequest request)
 {
     this.SerializeReplyHeader(response.Stat == null ? 0L : response.Stat.Mzxid, response.ResultCode, request.Xid);
     this.SerializeStat(response.Stat);
 }
Ejemplo n.º 13
0
 private void SerializeResponseGetData(RequestResponse response, IZooKeeperRequest request)
 {
     this.SerializeReplyHeader(response.Stat == null ? 0L : response.Stat.Mzxid, response.ResultCode, request.Xid);
     this.binaryWriter.WriteByteArray32BitPrefixLengthBE((byte[])response.Content);
     this.SerializeStat(response.Stat);
 }