private Task<bool> DoHandshake(Rfc6455Handshake handshake)
        {
            return new Task<bool>(() =>
            {
                Socket.Send(Encoding.UTF8.GetBytes(handshake.ToString()), () =>
                {
                    StartReceiving();
                }
                , exception =>
                {

                });

                return SpinWait.SpinUntil(() => IsHandshakeDone, ConnectionTimeout);
            });
        }
 private Task<bool> DoSynchronHandshake(Rfc6455Handshake handshake)
 {
     var waiter = DoHandshake(handshake);
     waiter.Start();
     return waiter;
 }
        public virtual void Open()
        {

            if (this.IsConnected) return;

            var connectionstring = GetConnectionstring();

            var handshake = new Rfc6455Handshake(connectionstring, _origin, this);

            SetRemoteEndpoint();

            ConnectSocket();

            var r = DoSynchronHandshake(handshake).Result;

            if (r)
            {
                IsHandshakeDone = true;
                this.Connected();
            }
            else
                throw new Exception("Could not connect to server");

        }
Example #4
0
        private void DoHandshake(Rfc6455Handshake handshake)
        {
            var buffer = new byte[1024];
            Socket.Send(Encoding.UTF8.GetBytes(handshake.ToString()), () => Socket.Receive(buffer, r =>
            {
                //check if only a partial handshake received (noticed with/ IIS8 hosts)
                if (r < 2)
                {
                    //read the rest of the handshake
                    ReadHandshakeContinue(buffer, r);
                }
                IsHandshakeDone = true;

                Receive();

                if (!this.IsPrimitive)
                {
                    BindUnboundBindings();
                }

                if (this.OnSocketOpen != null)
                    this.OnSocketOpen.Invoke(this, null);
            }, err => FireOnClose()),
                        err => FireOnClose());
        }
Example #5
0
        public void Open()
        {
            if (this.IsConnected) return;

            var connectionstring = GetConnectionstring();

            var handshake = new Rfc6455Handshake(connectionstring, this._origin);

            SetRemoteEndpoint();

            ConnectSocket();

            DoHandshake(handshake);
        }
        private Task<bool> DoHandshake(Rfc6455Handshake handshake)
        {

            return new Task<bool>(() =>
            {
                var cts = new CancellationTokenSource();
                var token = cts.Token;

                var working = true;

                var buffer = new byte[1024];
                Socket.Send(Encoding.UTF8.GetBytes(handshake.ToString()), () => Socket.Receive(buffer, r =>
                {
                    Receive();
                    IsHandshakeDone = true;

                    foreach (var ctrl in this.Controllers.GetAll())
                    {
                        ctrl.BindUnboundSubscriptions();
                    }
                    working = false;
                }, err => FireOnDisconnected()),
                            err => FireOnDisconnected());


                while (working)
                {
                    if (token.IsCancellationRequested)
                        return false;
                    Thread.Sleep(1);
                }
                return true;
            });


        }