Merge pull request #1628 from bollhals/fix/InboundCommand

lukebakken · web-flow · commit e247e8b14a90 · 2024-07-08T10:42:24.000-07:00
make IncomingCommand a class and simplify code around it
diff --git a/projects/RabbitMQ.Client/client/RentedMemory.cs b/projects/RabbitMQ.Client/client/RentedMemory.cs
@@ -36,8 +36,6 @@ namespace RabbitMQ.Client
 {
     internal struct RentedMemory : IDisposable
     {
-        private bool _disposedValue;
-
         internal RentedMemory(byte[] rentedArray)
             : this(new ReadOnlyMemory<byte>(rentedArray), rentedArray)
         {
@@ -47,21 +45,20 @@ internal RentedMemory(ReadOnlyMemory<byte> memory, byte[] rentedArray)
         {
             Memory = memory;
             RentedArray = rentedArray;
-            _disposedValue = false;
         }
 
-        internal readonly ReadOnlyMemory<byte> Memory;
-
-        internal readonly byte[] ToArray()
-        {
-            return Memory.ToArray();
-        }
+        internal ReadOnlyMemory<byte> Memory;
 
         internal readonly int Size => Memory.Length;
 
         internal readonly ReadOnlySpan<byte> Span => Memory.Span;
 
-        internal readonly byte[] RentedArray;
+        internal byte[] RentedArray;
+
+        internal readonly byte[] ToArray()
+        {
+            return Memory.ToArray();
+        }
 
         internal readonly ReadOnlyMemory<byte> CopyToMemory()
         {
@@ -70,14 +67,11 @@ internal readonly ReadOnlyMemory<byte> CopyToMemory()
 
         public void Dispose()
         {
-            if (!_disposedValue)
+            if (RentedArray != null)
             {
-                if (RentedArray != null)
-                {
-                    ArrayPool<byte>.Shared.Return(RentedArray);
-                }
-
-                _disposedValue = true;
+                ArrayPool<byte>.Shared.Return(RentedArray);
+                RentedArray = default;
+                Memory = default;
             }
         }
     }
diff --git a/projects/RabbitMQ.Client/client/framing/Channel.cs b/projects/RabbitMQ.Client/client/framing/Channel.cs
@@ -88,17 +88,17 @@ protected override Task<bool> DispatchCommandAsync(IncomingCommand cmd, Cancella
                     }
                 case ProtocolCommandId.BasicAck:
                     {
-                        HandleBasicAck(in cmd);
+                        HandleBasicAck(cmd);
                         return Task.FromResult(true);
                     }
                 case ProtocolCommandId.BasicNack:
                     {
-                        HandleBasicNack(in cmd);
+                        HandleBasicNack(cmd);
                         return Task.FromResult(true);
                     }
                 case ProtocolCommandId.BasicReturn:
                     {
-                        HandleBasicReturn(in cmd);
+                        HandleBasicReturn(cmd);
                         return Task.FromResult(true);
                     }
                 case ProtocolCommandId.ChannelClose:
@@ -118,7 +118,7 @@ protected override Task<bool> DispatchCommandAsync(IncomingCommand cmd, Cancella
                     }
                 case ProtocolCommandId.ConnectionBlocked:
                     {
-                        HandleConnectionBlocked(in cmd);
+                        HandleConnectionBlocked(cmd);
                         return Task.FromResult(true);
                     }
                 case ProtocolCommandId.ConnectionClose:
@@ -143,7 +143,7 @@ protected override Task<bool> DispatchCommandAsync(IncomingCommand cmd, Cancella
                     }
                 case ProtocolCommandId.ConnectionUnblocked:
                     {
-                        HandleConnectionUnblocked(in cmd);
+                        HandleConnectionUnblocked(cmd);
                         return Task.FromResult(true);
                     }
                 default:
diff --git a/projects/RabbitMQ.Client/client/impl/ChannelBase.cs b/projects/RabbitMQ.Client/client/impl/ChannelBase.cs
@@ -54,7 +54,7 @@ internal abstract class ChannelBase : IChannel, IRecoverable
         internal TaskCompletionSource<ConnectionStartDetails> m_connectionStartCell;
         private Exception m_connectionStartException = null;
 
-        // AMQP only allows one RPC operation to be active at a time. 
+        // AMQP only allows one RPC operation to be active at a time.
         protected readonly SemaphoreSlim _rpcSemaphore = new SemaphoreSlim(1, 1);
         private readonly RpcContinuationQueue _continuationQueue = new RpcContinuationQueue();
         private readonly ManualResetEventSlim _flowControlBlock = new ManualResetEventSlim(true);
@@ -425,8 +425,8 @@ private async Task HandleCommandAsync(IncomingCommand cmd, CancellationToken can
             /*
              * If DispatchCommandAsync returns `true`, it means that the incoming command is server-originated, and has
              * already been handled.
-             * 
-             * Else, the incoming command is the return of an RPC call, and must be handled. 
+             *
+             * Else, the incoming command is the return of an RPC call, and must be handled.
              */
             if (false == await DispatchCommandAsync(cmd, cancellationToken)
                 .ConfigureAwait(false))
@@ -561,7 +561,7 @@ public Task ConnectionTuneOkAsync(ushort channelMax, uint frameMax, ushort heart
             return ModelSendAsync(method, cancellationToken).AsTask();
         }
 
-        protected void HandleBasicAck(in IncomingCommand cmd)
+        protected void HandleBasicAck(IncomingCommand cmd)
         {
             try
             {
@@ -580,7 +580,7 @@ protected void HandleBasicAck(in IncomingCommand cmd)
             }
         }
 
-        protected void HandleBasicNack(in IncomingCommand cmd)
+        protected void HandleBasicNack(IncomingCommand cmd)
         {
             try
             {
@@ -679,17 +679,17 @@ await ConsumerDispatcher.HandleBasicDeliverAsync(
                         method._exchange,
                         method._routingKey,
                         header,
-                        cmd.Body,
+                        /*
+                         * Takeover Body so it doesn't get returned as it is necessary
+                         * for handling the Basic.Deliver method by client code.
+                         */
+                        cmd.TakeoverBody(),
                         cancellationToken).ConfigureAwait(false);
                 return true;
             }
             finally
             {
-                /*
-                 * Note: do not return the Body as it is necessary for handling
-                 * the Basic.Deliver method by client code
-                 */
-                cmd.ReturnMethodAndHeaderBuffers();
+                cmd.ReturnBuffers();
             }
         }
 
@@ -698,7 +698,7 @@ protected virtual ulong AdjustDeliveryTag(ulong deliveryTag)
             return deliveryTag;
         }
 
-        protected void HandleBasicReturn(in IncomingCommand cmd)
+        protected void HandleBasicReturn(IncomingCommand cmd)
         {
             try
             {
@@ -800,7 +800,7 @@ await ModelSendAsync(method, cancellationToken).
             }
         }
 
-        protected void HandleConnectionBlocked(in IncomingCommand cmd)
+        protected void HandleConnectionBlocked(IncomingCommand cmd)
         {
             try
             {
@@ -851,7 +851,7 @@ await ModelSendAsync(replyMethod, cancellationToken)
         protected async Task<bool> HandleConnectionSecureAsync(IncomingCommand _)
         {
             var k = (ConnectionSecureOrTuneAsyncRpcContinuation)_continuationQueue.Next();
-            await k.HandleCommandAsync(IncomingCommand.Empty)
+            await k.HandleCommandAsync(new IncomingCommand())
                 .ConfigureAwait(false); // release the continuation.
             return true;
         }
@@ -903,7 +903,7 @@ await k.HandleCommandAsync(cmd)
             return true;
         }
 
-        protected void HandleConnectionUnblocked(in IncomingCommand cmd)
+        protected void HandleConnectionUnblocked(IncomingCommand cmd)
         {
             try
             {
diff --git a/projects/RabbitMQ.Client/client/impl/CommandAssembler.cs b/projects/RabbitMQ.Client/client/impl/CommandAssembler.cs
@@ -44,34 +44,19 @@ internal sealed class CommandAssembler
     {
         private const int MaxArrayOfBytesSize = 2_147_483_591;
 
-        private ProtocolCommandId _commandId;
-        private RentedMemory _methodMemory;
-        private RentedMemory _headerMemory;
-        private RentedMemory _bodyMemory;
+        private readonly IncomingCommand _currentCommand;
+        private readonly uint _maxBodyLength;
+
         private int _remainingBodyByteCount;
-        private int _offset;
         private AssemblyState _state;
 
-        private readonly uint _maxBodyLength;
-
         public CommandAssembler(uint maxBodyLength)
         {
+            _currentCommand = new IncomingCommand();
             _maxBodyLength = maxBodyLength;
-            Reset();
-        }
-
-        private void Reset()
-        {
-            _commandId = default;
-            _methodMemory = default;
-            _headerMemory = default;
-            _bodyMemory = default;
-            _remainingBodyByteCount = 0;
-            _offset = 0;
-            _state = AssemblyState.ExpectingMethod;
         }
 
-        public void HandleFrame(InboundFrame frame, out IncomingCommand command)
+        public IncomingCommand? HandleFrame(InboundFrame frame)
         {
             switch (_state)
             {
@@ -88,13 +73,14 @@ public void HandleFrame(InboundFrame frame, out IncomingCommand command)
 
             if (_state != AssemblyState.Complete)
             {
-                command = IncomingCommand.Empty;
-                return;
+                return default;
             }
 
             RabbitMqClientEventSource.Log.CommandReceived();
-            command = new IncomingCommand(_commandId, _methodMemory, _headerMemory, _bodyMemory);
-            Reset();
+            _remainingBodyByteCount = 0;
+            _state = AssemblyState.ExpectingMethod;
+
+            return _currentCommand;
         }
 
         private void ParseMethodFrame(InboundFrame frame)
@@ -104,10 +90,10 @@ private void ParseMethodFrame(InboundFrame frame)
                 throw new UnexpectedFrameException(frame.Type);
             }
 
-            _commandId = (ProtocolCommandId)NetworkOrderDeserializer.ReadUInt32(frame.Payload.Span);
-            _methodMemory = frame.TakeoverPayload(Framing.Method.ArgumentsOffset);
+            _currentCommand.CommandId = (ProtocolCommandId)NetworkOrderDeserializer.ReadUInt32(frame.Payload.Span);
+            _currentCommand.Method = frame.TakeoverPayload(Framing.Method.ArgumentsOffset);
 
-            switch (_commandId)
+            switch (_currentCommand.CommandId)
             {
                 // Commands with payload
                 case ProtocolCommandId.BasicGetOk:
@@ -154,7 +140,7 @@ private void ParseHeaderFrame(InboundFrame frame)
             }
             else
             {
-                _headerMemory = frame.TakeoverPayload(Framing.Header.HeaderArgumentOffset);
+                _currentCommand.Header = frame.TakeoverPayload(Framing.Header.HeaderArgumentOffset);
             }
 
             _remainingBodyByteCount = (int)totalBodyBytes;
@@ -174,25 +160,25 @@ private void ParseBodyFrame(InboundFrame frame)
                 throw new MalformedFrameException($"Overlong content body received - {_remainingBodyByteCount} bytes remaining, {payloadLength} bytes received");
             }
 
-            if (_bodyMemory.RentedArray is null)
+            if (_currentCommand.Body.RentedArray is null)
             {
                 // check for single frame payload for an early exit
                 if (payloadLength == _remainingBodyByteCount)
                 {
-                    _bodyMemory = frame.TakeoverPayload(0);
+                    _currentCommand.Body = frame.TakeoverPayload(0);
                     _state = AssemblyState.Complete;
                     return;
                 }
 
                 // Is returned by IncomingCommand.ReturnPayload in Session.HandleFrame
                 var rentedBodyArray = ArrayPool<byte>.Shared.Rent(_remainingBodyByteCount);
-                _bodyMemory = new RentedMemory(new ReadOnlyMemory<byte>(rentedBodyArray, 0, _remainingBodyByteCount), rentedBodyArray);
+                _currentCommand.Body.RentedArray = rentedBodyArray;
+                _currentCommand.Body.Memory = new ReadOnlyMemory<byte>(rentedBodyArray, 0, _remainingBodyByteCount);
             }
 
-            frame.Payload.Span.CopyTo(_bodyMemory.RentedArray.AsSpan(_offset));
+            frame.Payload.Span.CopyTo(_currentCommand.Body.RentedArray.AsSpan(_currentCommand.Body.Memory.Length - _remainingBodyByteCount));
             frame.TryReturnPayload();
             _remainingBodyByteCount -= payloadLength;
-            _offset += payloadLength;
             UpdateContentBodyState();
         }
 
diff --git a/projects/RabbitMQ.Client/client/impl/IncomingCommand.cs b/projects/RabbitMQ.Client/client/impl/IncomingCommand.cs
@@ -34,60 +34,29 @@
 
 namespace RabbitMQ.Client.Impl
 {
-    internal readonly struct IncomingCommand
+    internal sealed class IncomingCommand
     {
-        public static readonly IncomingCommand Empty = default;
+        public ProtocolCommandId CommandId;
 
-        public readonly ProtocolCommandId CommandId;
+        public RentedMemory Method;
+        public RentedMemory Header;
+        public RentedMemory Body;
 
-        public readonly RentedMemory Method;
-        public readonly RentedMemory Header;
-        public readonly RentedMemory Body;
+        public ReadOnlySpan<byte> MethodSpan => Method.Memory.Span;
+        public ReadOnlySpan<byte> HeaderSpan => Header.Memory.Span;
+        public ReadOnlySpan<byte> BodySpan => Body.Memory.Span;
 
-        public readonly bool IsEmpty => CommandId is default(ProtocolCommandId);
-
-        public IncomingCommand(ProtocolCommandId commandId,
-            RentedMemory method, RentedMemory header, RentedMemory body)
-        {
-            CommandId = commandId;
-            Method = method;
-            Header = header;
-            Body = body;
-        }
-
-        public ReadOnlySpan<byte> MethodSpan
+        public RentedMemory TakeoverBody()
         {
-            get
-            {
-                return Method.Memory.Span;
-            }
+            RentedMemory body = Body;
+            Body = default;
+            return body;
         }
 
-        public ReadOnlySpan<byte> HeaderSpan
-        {
-            get
-            {
-                return Header.Memory.Span;
-            }
-        }
-
-        public ReadOnlySpan<byte> BodySpan
-        {
-            get
-            {
-                return Body.Memory.Span;
-            }
-        }
-
-        public void ReturnMethodAndHeaderBuffers()
+        public void ReturnBuffers()
         {
             Method.Dispose();
             Header.Dispose();
-        }
-
-        public void ReturnBuffers()
-        {
-            ReturnMethodAndHeaderBuffers();
             Body.Dispose();
         }
     }
diff --git a/projects/RabbitMQ.Client/client/impl/Session.cs b/projects/RabbitMQ.Client/client/impl/Session.cs
@@ -48,9 +48,8 @@ public Session(Connection connection, ushort channelNumber, uint maxBodyLength)
 
         public override Task HandleFrameAsync(InboundFrame frame, CancellationToken cancellationToken)
         {
-            _assembler.HandleFrame(frame, out IncomingCommand cmd);
-
-            if (cmd.IsEmpty)
+            IncomingCommand cmd = _assembler.HandleFrame(frame);
+            if (cmd is null)
             {
                 return Task.CompletedTask;
             }

Original file line number	Diff line number	Diff line change
`@@ -36,8 +36,6 @@ namespace RabbitMQ.Client`
`36`	`36`	`{`
`37`	`37`	`internal struct RentedMemory : IDisposable`
`38`	`38`	`{`
`39`		`- private bool _disposedValue;`
`40`		`-`
`41`	`39`	`internal RentedMemory(byte[] rentedArray)`
`42`	`40`	`: this(new ReadOnlyMemory<byte>(rentedArray), rentedArray)`
`43`	`41`	`{`
`@@ -47,21 +45,20 @@ internal RentedMemory(ReadOnlyMemory<byte> memory, byte[] rentedArray)`
`47`	`45`	`{`
`48`	`46`	`Memory = memory;`
`49`	`47`	`RentedArray = rentedArray;`
`50`		`- _disposedValue = false;`
`51`	`48`	`}`
`52`	`49`
`53`		`- internal readonly ReadOnlyMemory<byte> Memory;`
`54`		`-`
`55`		`- internal readonly byte[] ToArray()`
`56`		`- {`
`57`		`- return Memory.ToArray();`
`58`		`- }`
	`50`	`+ internal ReadOnlyMemory<byte> Memory;`
`59`	`51`
`60`	`52`	`internal readonly int Size => Memory.Length;`
`61`	`53`
`62`	`54`	`internal readonly ReadOnlySpan<byte> Span => Memory.Span;`
`63`	`55`
`64`		`- internal readonly byte[] RentedArray;`
	`56`	`+ internal byte[] RentedArray;`
	`57`	`+`
	`58`	`+ internal readonly byte[] ToArray()`
	`59`	`+ {`
	`60`	`+ return Memory.ToArray();`
	`61`	`+ }`
`65`	`62`
`66`	`63`	`internal readonly ReadOnlyMemory<byte> CopyToMemory()`
`67`	`64`	`{`
`@@ -70,14 +67,11 @@ internal readonly ReadOnlyMemory<byte> CopyToMemory()`
`70`	`67`
`71`	`68`	`public void Dispose()`
`72`	`69`	`{`
`73`		`- if (!_disposedValue)`
	`70`	`+ if (RentedArray != null)`
`74`	`71`	`{`
`75`		`- if (RentedArray != null)`
`76`		`- {`
`77`		`- ArrayPool<byte>.Shared.Return(RentedArray);`
`78`		`- }`
`79`		`-`
`80`		`- _disposedValue = true;`
	`72`	`+ ArrayPool<byte>.Shared.Return(RentedArray);`
	`73`	`+ RentedArray = default;`
	`74`	`+ Memory = default;`
`81`	`75`	`}`
`82`	`76`	`}`
`83`	`77`	`}`
Original file line number	Diff line number	Diff line change
`@@ -88,17 +88,17 @@ protected override Task<bool> DispatchCommandAsync(IncomingCommand cmd, Cancella`
`88`	`88`	`}`
`89`	`89`	`case ProtocolCommandId.BasicAck:`
`90`	`90`	`{`
`91`		`- HandleBasicAck(in cmd);`
	`91`	`+ HandleBasicAck(cmd);`
`92`	`92`	`return Task.FromResult(true);`
`93`	`93`	`}`
`94`	`94`	`case ProtocolCommandId.BasicNack:`
`95`	`95`	`{`
`96`		`- HandleBasicNack(in cmd);`
	`96`	`+ HandleBasicNack(cmd);`
`97`	`97`	`return Task.FromResult(true);`
`98`	`98`	`}`
`99`	`99`	`case ProtocolCommandId.BasicReturn:`
`100`	`100`	`{`
`101`		`- HandleBasicReturn(in cmd);`
	`101`	`+ HandleBasicReturn(cmd);`
`102`	`102`	`return Task.FromResult(true);`
`103`	`103`	`}`
`104`	`104`	`case ProtocolCommandId.ChannelClose:`
`@@ -118,7 +118,7 @@ protected override Task<bool> DispatchCommandAsync(IncomingCommand cmd, Cancella`
`118`	`118`	`}`
`119`	`119`	`case ProtocolCommandId.ConnectionBlocked:`
`120`	`120`	`{`
`121`		`- HandleConnectionBlocked(in cmd);`
	`121`	`+ HandleConnectionBlocked(cmd);`
`122`	`122`	`return Task.FromResult(true);`
`123`	`123`	`}`
`124`	`124`	`case ProtocolCommandId.ConnectionClose:`
`@@ -143,7 +143,7 @@ protected override Task<bool> DispatchCommandAsync(IncomingCommand cmd, Cancella`
`143`	`143`	`}`
`144`	`144`	`case ProtocolCommandId.ConnectionUnblocked:`
`145`	`145`	`{`
`146`		`- HandleConnectionUnblocked(in cmd);`
	`146`	`+ HandleConnectionUnblocked(cmd);`
`147`	`147`	`return Task.FromResult(true);`
`148`	`148`	`}`
`149`	`149`	`default:`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ internal abstract class ChannelBase : IChannel, IRecoverable`
`54`	`54`	`internal TaskCompletionSource<ConnectionStartDetails> m_connectionStartCell;`
`55`	`55`	`private Exception m_connectionStartException = null;`
`56`	`56`
`57`		`- // AMQP only allows one RPC operation to be active at a time.`
	`57`	`+ // AMQP only allows one RPC operation to be active at a time.`
`58`	`58`	`protected readonly SemaphoreSlim _rpcSemaphore = new SemaphoreSlim(1, 1);`
`59`	`59`	`private readonly RpcContinuationQueue _continuationQueue = new RpcContinuationQueue();`
`60`	`60`	`private readonly ManualResetEventSlim _flowControlBlock = new ManualResetEventSlim(true);`
`@@ -425,8 +425,8 @@ private async Task HandleCommandAsync(IncomingCommand cmd, CancellationToken can`
`425`	`425`	`/*`
`426`	`426`	* If DispatchCommandAsync returns `true`, it means that the incoming command is server-originated, and has
`427`	`427`	`* already been handled.`
`428`		`- *`
`429`		`- * Else, the incoming command is the return of an RPC call, and must be handled.`
	`428`	`+ *`
	`429`	`+ * Else, the incoming command is the return of an RPC call, and must be handled.`
`430`	`430`	`*/`
`431`	`431`	`if (false == await DispatchCommandAsync(cmd, cancellationToken)`
`432`	`432`	`.ConfigureAwait(false))`
`@@ -561,7 +561,7 @@ public Task ConnectionTuneOkAsync(ushort channelMax, uint frameMax, ushort heart`
`561`	`561`	`return ModelSendAsync(method, cancellationToken).AsTask();`
`562`	`562`	`}`
`563`	`563`
`564`		`- protected void HandleBasicAck(in IncomingCommand cmd)`
	`564`	`+ protected void HandleBasicAck(IncomingCommand cmd)`
`565`	`565`	`{`
`566`	`566`	`try`
`567`	`567`	`{`
`@@ -580,7 +580,7 @@ protected void HandleBasicAck(in IncomingCommand cmd)`
`580`	`580`	`}`
`581`	`581`	`}`
`582`	`582`
`583`		`- protected void HandleBasicNack(in IncomingCommand cmd)`
	`583`	`+ protected void HandleBasicNack(IncomingCommand cmd)`
`584`	`584`	`{`
`585`	`585`	`try`
`586`	`586`	`{`
`@@ -679,17 +679,17 @@ await ConsumerDispatcher.HandleBasicDeliverAsync(`
`679`	`679`	`method._exchange,`
`680`	`680`	`method._routingKey,`
`681`	`681`	`header,`
`682`		`- cmd.Body,`
	`682`	`+ /*`
	`683`	`+ * Takeover Body so it doesn't get returned as it is necessary`
	`684`	`+ * for handling the Basic.Deliver method by client code.`
	`685`	`+ */`
	`686`	`+ cmd.TakeoverBody(),`
`683`	`687`	`cancellationToken).ConfigureAwait(false);`
`684`	`688`	`return true;`
`685`	`689`	`}`
`686`	`690`	`finally`
`687`	`691`	`{`
`688`		`- /*`
`689`		`- * Note: do not return the Body as it is necessary for handling`
`690`		`- * the Basic.Deliver method by client code`
`691`		`- */`
`692`		`- cmd.ReturnMethodAndHeaderBuffers();`
	`692`	`+ cmd.ReturnBuffers();`
`693`	`693`	`}`
`694`	`694`	`}`
`695`	`695`
`@@ -698,7 +698,7 @@ protected virtual ulong AdjustDeliveryTag(ulong deliveryTag)`
`698`	`698`	`return deliveryTag;`
`699`	`699`	`}`
`700`	`700`
`701`		`- protected void HandleBasicReturn(in IncomingCommand cmd)`
	`701`	`+ protected void HandleBasicReturn(IncomingCommand cmd)`
`702`	`702`	`{`
`703`	`703`	`try`
`704`	`704`	`{`
`@@ -800,7 +800,7 @@ await ModelSendAsync(method, cancellationToken).`
`800`	`800`	`}`
`801`	`801`	`}`
`802`	`802`
`803`		`- protected void HandleConnectionBlocked(in IncomingCommand cmd)`
	`803`	`+ protected void HandleConnectionBlocked(IncomingCommand cmd)`
`804`	`804`	`{`
`805`	`805`	`try`
`806`	`806`	`{`
`@@ -851,7 +851,7 @@ await ModelSendAsync(replyMethod, cancellationToken)`
`851`	`851`	`protected async Task<bool> HandleConnectionSecureAsync(IncomingCommand _)`
`852`	`852`	`{`
`853`	`853`	`var k = (ConnectionSecureOrTuneAsyncRpcContinuation)_continuationQueue.Next();`
`854`		`- await k.HandleCommandAsync(IncomingCommand.Empty)`
	`854`	`+ await k.HandleCommandAsync(new IncomingCommand())`
`855`	`855`	`.ConfigureAwait(false); // release the continuation.`
`856`	`856`	`return true;`
`857`	`857`	`}`
`@@ -903,7 +903,7 @@ await k.HandleCommandAsync(cmd)`
`903`	`903`	`return true;`
`904`	`904`	`}`
`905`	`905`
`906`		`- protected void HandleConnectionUnblocked(in IncomingCommand cmd)`
	`906`	`+ protected void HandleConnectionUnblocked(IncomingCommand cmd)`
`907`	`907`	`{`
`908`	`908`	`try`
`909`	`909`	`{`
Original file line number	Diff line number	Diff line change
`@@ -44,34 +44,19 @@ internal sealed class CommandAssembler`
`44`	`44`	`{`
`45`	`45`	`private const int MaxArrayOfBytesSize = 2_147_483_591;`
`46`	`46`
`47`		`- private ProtocolCommandId _commandId;`
`48`		`- private RentedMemory _methodMemory;`
`49`		`- private RentedMemory _headerMemory;`
`50`		`- private RentedMemory _bodyMemory;`
	`47`	`+ private readonly IncomingCommand _currentCommand;`
	`48`	`+ private readonly uint _maxBodyLength;`
	`49`	`+`
`51`	`50`	`private int _remainingBodyByteCount;`
`52`		`- private int _offset;`
`53`	`51`	`private AssemblyState _state;`
`54`	`52`
`55`		`- private readonly uint _maxBodyLength;`
`56`		`-`
`57`	`53`	`public CommandAssembler(uint maxBodyLength)`
`58`	`54`	`{`
	`55`	`+ _currentCommand = new IncomingCommand();`
`59`	`56`	`_maxBodyLength = maxBodyLength;`
`60`		`- Reset();`
`61`		`- }`
`62`		`-`
`63`		`- private void Reset()`
`64`		`- {`
`65`		`- _commandId = default;`
`66`		`- _methodMemory = default;`
`67`		`- _headerMemory = default;`
`68`		`- _bodyMemory = default;`
`69`		`- _remainingBodyByteCount = 0;`
`70`		`- _offset = 0;`
`71`		`- _state = AssemblyState.ExpectingMethod;`
`72`	`57`	`}`
`73`	`58`
`74`		`- public void HandleFrame(InboundFrame frame, out IncomingCommand command)`
	`59`	`+ public IncomingCommand? HandleFrame(InboundFrame frame)`
`75`	`60`	`{`
`76`	`61`	`switch (_state)`
`77`	`62`	`{`
`@@ -88,13 +73,14 @@ public void HandleFrame(InboundFrame frame, out IncomingCommand command)`
`88`	`73`
`89`	`74`	`if (_state != AssemblyState.Complete)`
`90`	`75`	`{`
`91`		`- command = IncomingCommand.Empty;`
`92`		`- return;`
	`76`	`+ return default;`
`93`	`77`	`}`
`94`	`78`
`95`	`79`	`RabbitMqClientEventSource.Log.CommandReceived();`
`96`		`- command = new IncomingCommand(_commandId, _methodMemory, _headerMemory, _bodyMemory);`
`97`		`- Reset();`
	`80`	`+ _remainingBodyByteCount = 0;`
	`81`	`+ _state = AssemblyState.ExpectingMethod;`
	`82`	`+`
	`83`	`+ return _currentCommand;`
`98`	`84`	`}`
`99`	`85`
`100`	`86`	`private void ParseMethodFrame(InboundFrame frame)`
`@@ -104,10 +90,10 @@ private void ParseMethodFrame(InboundFrame frame)`
`104`	`90`	`throw new UnexpectedFrameException(frame.Type);`
`105`	`91`	`}`
`106`	`92`
`107`		`- _commandId = (ProtocolCommandId)NetworkOrderDeserializer.ReadUInt32(frame.Payload.Span);`
`108`		`- _methodMemory = frame.TakeoverPayload(Framing.Method.ArgumentsOffset);`
	`93`	`+ _currentCommand.CommandId = (ProtocolCommandId)NetworkOrderDeserializer.ReadUInt32(frame.Payload.Span);`
	`94`	`+ _currentCommand.Method = frame.TakeoverPayload(Framing.Method.ArgumentsOffset);`
`109`	`95`
`110`		`- switch (_commandId)`
	`96`	`+ switch (_currentCommand.CommandId)`
`111`	`97`	`{`
`112`	`98`	`// Commands with payload`
`113`	`99`	`case ProtocolCommandId.BasicGetOk:`
`@@ -154,7 +140,7 @@ private void ParseHeaderFrame(InboundFrame frame)`
`154`	`140`	`}`
`155`	`141`	`else`
`156`	`142`	`{`
`157`		`- _headerMemory = frame.TakeoverPayload(Framing.Header.HeaderArgumentOffset);`
	`143`	`+ _currentCommand.Header = frame.TakeoverPayload(Framing.Header.HeaderArgumentOffset);`
`158`	`144`	`}`
`159`	`145`
`160`	`146`	`_remainingBodyByteCount = (int)totalBodyBytes;`
`@@ -174,25 +160,25 @@ private void ParseBodyFrame(InboundFrame frame)`
`174`	`160`	`throw new MalformedFrameException($"Overlong content body received - {_remainingBodyByteCount} bytes remaining, {payloadLength} bytes received");`
`175`	`161`	`}`
`176`	`162`
`177`		`- if (_bodyMemory.RentedArray is null)`
	`163`	`+ if (_currentCommand.Body.RentedArray is null)`
`178`	`164`	`{`
`179`	`165`	`// check for single frame payload for an early exit`
`180`	`166`	`if (payloadLength == _remainingBodyByteCount)`
`181`	`167`	`{`
`182`		`- _bodyMemory = frame.TakeoverPayload(0);`
	`168`	`+ _currentCommand.Body = frame.TakeoverPayload(0);`
`183`	`169`	`_state = AssemblyState.Complete;`
`184`	`170`	`return;`
`185`	`171`	`}`
`186`	`172`
`187`	`173`	`// Is returned by IncomingCommand.ReturnPayload in Session.HandleFrame`
`188`	`174`	`var rentedBodyArray = ArrayPool<byte>.Shared.Rent(_remainingBodyByteCount);`
`189`		`- _bodyMemory = new RentedMemory(new ReadOnlyMemory<byte>(rentedBodyArray, 0, _remainingBodyByteCount), rentedBodyArray);`
	`175`	`+ _currentCommand.Body.RentedArray = rentedBodyArray;`
	`176`	`+ _currentCommand.Body.Memory = new ReadOnlyMemory<byte>(rentedBodyArray, 0, _remainingBodyByteCount);`
`190`	`177`	`}`
`191`	`178`
`192`		`- frame.Payload.Span.CopyTo(_bodyMemory.RentedArray.AsSpan(_offset));`
	`179`	`+ frame.Payload.Span.CopyTo(_currentCommand.Body.RentedArray.AsSpan(_currentCommand.Body.Memory.Length - _remainingBodyByteCount));`
`193`	`180`	`frame.TryReturnPayload();`
`194`	`181`	`_remainingBodyByteCount -= payloadLength;`
`195`		`- _offset += payloadLength;`
`196`	`182`	`UpdateContentBodyState();`
`197`	`183`	`}`
`198`	`184`
Original file line number	Diff line number	Diff line change
`@@ -48,9 +48,8 @@ public Session(Connection connection, ushort channelNumber, uint maxBodyLength)`
`48`	`48`
`49`	`49`	`public override Task HandleFrameAsync(InboundFrame frame, CancellationToken cancellationToken)`
`50`	`50`	`{`
`51`		`- _assembler.HandleFrame(frame, out IncomingCommand cmd);`
`52`		`-`
`53`		`- if (cmd.IsEmpty)`
	`51`	`+ IncomingCommand cmd = _assembler.HandleFrame(frame);`
	`52`	`+ if (cmd is null)`
`54`	`53`	`{`
`55`	`54`	`return Task.CompletedTask;`
`56`	`55`	`}`