Example #1
0
 void OnHeartbeatEvent(SocketLinkSession session, HeartbeatEvent e)
 {
     Timer.Cancel(session.HeartbeatTimeoutToken);
     session.HeartbeatTimeoutToken = Timer.Reserve(session, 15);
 }
Example #2
0
        protected void ReceiveInternal(int bytesTransferred)
        {
            Diag.AddBytesReceived(bytesTransferred);

            Log.Trace("{0} {1} received {2} byte(s)",
                link.Name, Handle, bytesTransferred);

            recvBuffer.Stretch(bytesTransferred);

            if (beginning)
            {
                recvBuffer.Rewind();
                int payloadLength;
                int numLengthBytes = recvBuffer.ReadUInt29(out payloadLength);
                recvBuffer.Shrink(numLengthBytes);
                lengthToReceive = payloadLength;
            }

            // Handle split packets.
            if (recvBuffer.Length < lengthToReceive)
            {
                BeginReceive(false);
                return;
            }

            while (true)
            {
                recvBuffer.MarkToRead(lengthToReceive);

                if (BufferTransform != null)
                {
                    try
                    {
                        BufferTransform.InverseTransform(recvBuffer, lengthToReceive);
                    }
                    catch (Exception e)
                    {
                        Log.Error("{0} {1} buffer transform error: {2}", link.Name, Handle, e.Message);
                        recvBuffer.Shrink(lengthToReceive);
                        break;
                    }
                    recvBuffer.Rewind();
                }

                int typeId;
                recvBuffer.ReadUInt29(out typeId);

                // Heartbeat
                if (typeId == HeartbeatEvent.TypeId)
                {
                    var heartbeat = new HeartbeatEvent();
                    heartbeat.Load(recvBuffer);

                    if (!Polarity)
                    {
                        // Heartbeat feedback
                        Send(heartbeat);

                        Log.Debug("{0} {1} heartbeat {2}", link.Name, Handle, heartbeat.Timestamp);
                    }

                    if (link.HeartbeatEventHandler != null)
                    {
                        link.HeartbeatEventHandler(this, heartbeat);
                    }
                }
                else
                {
                    var retrieved = Event.Create(typeId);
                    if (retrieved == null)
                    {
                        Log.Error("{0} {1} unknown event type id {2}", link.Name, Handle, typeId);
                    }
                    else
                    {
                        retrieved.Load(recvBuffer);
                        retrieved.SessionHandle = Handle;
                        if (link.Preprocessor != null)
                        {
                            link.Preprocessor(retrieved, this);
                        }

                        Log.Debug("{0} {1} received event {2}", link.Name, Handle, retrieved);

                        link.Flow.Publish(retrieved);
                    }
                }

                recvBuffer.Trim();
                if (recvBuffer.IsEmpty)
                {
                    break;
                }

                int payloadLength;
                int numLengthBytes = recvBuffer.ReadUInt29(out payloadLength);
                recvBuffer.Shrink(numLengthBytes);
                lengthToReceive = payloadLength;

                if (recvBuffer.Length < lengthToReceive)
                {
                    BeginReceive(false);
                    return;
                }
            }

            BeginReceive(true);
        }