public override void HandleFrame(Frame frame)
        {
            lock (_closingLock)
            {
                if (!m_closing)
                {
                    base.HandleFrame(frame);
                    return;
                }
            }

            if (!m_closeServerInitiated && (frame.Type == Constants.FrameMethod))
            {
                MethodBase method = Connection.Protocol.DecodeMethodFrom(frame.GetReader());
                if ((method.ProtocolClassId == m_closeClassId)
                    && (method.ProtocolMethodId == m_closeMethodId))
                {
                    base.HandleFrame(frame);
                    return;
                }

                if ((method.ProtocolClassId == m_closeOkClassId)
                    && (method.ProtocolMethodId == m_closeOkMethodId))
                {
                    // This is the reply (CloseOk) we were looking for
                    // Call any listener attached to this session
                    Handler();
                }
            }

            // Either a non-method frame, or not what we were looking
            // for. Ignore it - we're quiescing.
        }
        public override void HandleFrame(Frame frame)
        {
            if (frame.Type == Constants.FrameMethod)
            {
                MethodBase method = Connection.Protocol.DecodeMethodFrom(frame.GetReader());
                if ((method.ProtocolClassId == ChannelCloseOk.ClassId)
                    && (method.ProtocolMethodId == ChannelCloseOk.MethodId))
                {
                    // This is the reply we were looking for. Release
                    // the channel with the reason we were passed in
                    // our constructor.
                    Close(m_reason);
                }
                else if ((method.ProtocolClassId == ChannelClose.ClassId)
                         && (method.ProtocolMethodId == ChannelClose.MethodId))
                {
                    // We're already shutting down the channel, so
                    // just send back an ok.
                    Transmit(CreateChannelCloseOk());
                }
            }

            // Either a non-method frame, or not what we were looking
            // for. Ignore it - we're quiescing.
        }
예제 #3
0
파일: Session.cs 프로젝트: nlhepler/mono
 public override void HandleFrame(Frame frame)
 {
     Command cmd = m_assembler.HandleFrame(frame);
     if (cmd != null)
     {
         OnCommandReceived(cmd);
     }
 }
        public Command HandleFrame(Frame f)
        {
            switch (m_state)
            {
                case AssemblyState.ExpectingMethod:
                {
                    if (f.Type != Constants.FrameMethod)
                    {
                        throw new UnexpectedFrameException(f);
                    }
                    m_command.Method = m_protocol.DecodeMethodFrom(f.GetReader());
                    m_state = m_command.Method.HasContent
                        ? AssemblyState.ExpectingContentHeader
                        : AssemblyState.Complete;
                    return CompletedCommand();
                }
                case AssemblyState.ExpectingContentHeader:
                {
                    if (f.Type != Constants.FrameHeader)
                    {
                        throw new UnexpectedFrameException(f);
                    }
                    NetworkBinaryReader reader = f.GetReader();
                    m_command.Header = m_protocol.DecodeContentHeaderFrom(reader);
                    m_remainingBodyBytes = m_command.Header.ReadFrom(reader);
                    UpdateContentBodyState();
                    return CompletedCommand();
                }
                case AssemblyState.ExpectingContentBody:
                {
                    if (f.Type != Constants.FrameBody)
                    {
                        throw new UnexpectedFrameException(f);
                    }
                    byte[] fragment = f.Payload;
                    m_command.AppendBodyFragment(fragment);
                    if ((ulong)fragment.Length > m_remainingBodyBytes)
                    {
                        throw new MalformedFrameException
                            (string.Format("Overlong content body received - {0} bytes remaining, {1} bytes received",
                                m_remainingBodyBytes,
                                fragment.Length));
                    }
                    m_remainingBodyBytes -= (ulong)fragment.Length;
                    UpdateContentBodyState();
                    return CompletedCommand();
                }
                case AssemblyState.Complete:
                default:
#if NETFX_CORE
                    Debug.WriteLine("Received frame in invalid state {0}; {1}", m_state, f);
#else
                    Trace.Fail(string.Format("Received frame in invalid state {0}; {1}", m_state, f));
#endif
                    return null;
            }
        }
예제 #5
0
        public static void CheckEmptyFrameSize() {
            Frame f = new Frame(CommonFraming.Constants.FrameBody, 0, m_emptyByteArray);
            MemoryStream stream = new MemoryStream();
            NetworkBinaryWriter writer = new NetworkBinaryWriter(stream);
            f.WriteTo(writer);
            long actualLength = stream.Length;

            if (EmptyFrameSize != actualLength) {
                string message =
                    string.Format("EmptyFrameSize is incorrect - defined as {0} where the computed value is in fact {1}.",
                                  EmptyFrameSize,
                                  actualLength);
                throw new ProtocolViolationException(message);
            }
        }
 public UnexpectedFrameException(Frame frame)
     : base("A frame of this type was not expected at this time")
 {
     m_frame = frame;
 }
 public void WriteFrame(Frame f)
 {
     m_frameHandler.WriteFrame(f);
     m_heartbeatWrite.Set();
 }
 public void WriteFrame(Frame frame)
 {
     lock (m_writer)
     {
         frame.WriteTo(m_writer);
         m_writer.Flush();
         //Console.WriteLine("OUTBOUND:");
         //DebugUtil.DumpProperties(frame, Console.Out, 2);
     }
 }
 public void WriteFrame(Frame frame)
 {
     lock (m_writer)
     {
         frame.WriteTo(m_writer);
         m_writer.Flush();
     }
 }
예제 #10
0
 public abstract void HandleFrame(Frame frame);
예제 #11
0
        public void Transmit(int channelNumber, ConnectionBase connection)
        {
            Frame frame = new Frame(CommonFraming.Constants.FrameMethod, channelNumber);
            NetworkBinaryWriter writer = frame.GetWriter();
            writer.Write((ushort) m_method.ProtocolClassId);
            writer.Write((ushort) m_method.ProtocolMethodId);
            MethodArgumentWriter argWriter = new MethodArgumentWriter(writer);
            m_method.WriteArgumentsTo(argWriter);
            argWriter.Flush();
            connection.WriteFrame(frame);

            if (m_method.HasContent) {
                byte[] body = Body;

                frame = new Frame(CommonFraming.Constants.FrameHeader, channelNumber);
                writer = frame.GetWriter();
                writer.Write((ushort) m_header.ProtocolClassId);
                m_header.WriteTo(writer, (ulong) body.Length);
                connection.WriteFrame(frame);

                int frameMax = (int) Math.Min(int.MaxValue, connection.FrameMax);
                int bodyPayloadMax = (frameMax == 0)
                    ? body.Length
                    : frameMax - EmptyFrameSize;
                for (int offset = 0; offset < body.Length; offset += bodyPayloadMax) {
                    int remaining = body.Length - offset;

                    frame = new Frame(CommonFraming.Constants.FrameBody, channelNumber);
                    writer = frame.GetWriter();
                    writer.Write(body, offset,
                                 (remaining < bodyPayloadMax) ? remaining : bodyPayloadMax);
                    connection.WriteFrame(frame);
                }
            }
        }
예제 #12
0
 public void TransmitAsSingleFrame(int channelNumber, Connection connection)
 {
     var frame = new Frame(Constants.FrameMethod, channelNumber);
     NetworkBinaryWriter writer = frame.GetWriter();
     writer.Write((ushort)Method.ProtocolClassId);
     writer.Write((ushort)Method.ProtocolMethodId);
     var argWriter = new MethodArgumentWriter(writer);
     Method.WriteArgumentsTo(argWriter);
     argWriter.Flush();
     connection.WriteFrame(frame);
 }
 public void WriteFrame(Frame frame)
 {
     lock (m_writer)
     {
         m_socket.Client.Poll(m_writeableStateTimeout, SelectMode.SelectWrite);
         frame.WriteTo(m_writer);
         m_writer.Flush();
     }
 }
        public override void HandleFrame(Frame frame)
        {
            if (frame.Type == CommonFraming.Constants.FrameMethod) {
                MethodBase method = Connection.Protocol.DecodeMethodFrom(frame.GetReader());
                if ((method.ProtocolClassId == m_replyClassId)
                    && (method.ProtocolMethodId == m_replyMethodId))
                {
                    // This is the reply we were looking for. Release
                    // the channel with the reason we were passed in
                    // our constructor.
                    Close(m_reason);
                    return;
                }
            }

            // Either a non-method frame, or not what we were looking
            // for. Ignore it - we're quiescing.
        }
 public void WriteFrame(Frame f)
 {
     m_frameHandler.WriteFrame(f);
 }