public override void Complete()
{
switch (_state)
{
case InternalState.IncompleteBufferWriter:
_state = InternalState.CompleteBufferWriter;
if (!DirectSerializationSupported)
{
CompatibilityExtensions.Assert(_bufferWriter != null, "Buffer writer has been set to get to this state.");
var data = _bufferWriter.WrittenSpan;
GrpcCallLog.SerializedMessage(_call.Logger, _call.RequestType, data.Length);
WriteMessage(data);
}
else
{
GrpcCallLog.SerializedMessage(_call.Logger, _call.RequestType, _payloadLength.GetValueOrDefault());
}
break;
default:
ThrowInvalidState(_state);
break;
}
}
public override IBufferWriter <byte> GetBufferWriter()
{
switch (_state)
{
case InternalState.Initialized:
var bufferWriter = ResolveBufferWriter();
// When writing directly to the buffer the header with message size needs to be written first
if (DirectSerializationSupported)
{
CompatibilityExtensions.Assert(_payloadLength != null, "A payload length is required for direct serialization.");
EnsureMessageSizeAllowed(_payloadLength.Value);
WriteHeader(_buffer, _payloadLength.Value, compress: false);
_bufferPosition += GrpcProtocolConstants.HeaderSize;
}
_state = InternalState.IncompleteBufferWriter;
return(bufferWriter);
case InternalState.IncompleteBufferWriter:
return(ResolveBufferWriter());
default:
ThrowInvalidState(_state);
return(default !);
}
}
private ICompressionProvider?ResolveCompressionProvider()
{
CompatibilityExtensions.Assert(
_call.RequestGrpcEncoding != null,
"Response encoding should have been calculated at this point.");
var canCompress =
GrpcProtocolHelpers.CanWriteCompressed(CallOptions.WriteOptions) &&
!string.Equals(_call.RequestGrpcEncoding, GrpcProtocolConstants.IdentityGrpcEncoding, StringComparison.Ordinal);
if (canCompress)
{
if (_call.Channel.CompressionProviders.TryGetValue(_call.RequestGrpcEncoding, out var compressionProvider))
{
return(compressionProvider);
}
throw new InvalidOperationException($"Could not find compression provider for '{_call.RequestGrpcEncoding}'.");
}
return(null);
}
private async Task <Metadata> GetResponseHeadersCoreAsync()
{
CompatibilityExtensions.Assert(_httpResponseTask != null);
try
{
var httpResponse = await _httpResponseTask.ConfigureAwait(false);
// Check if the headers have a status. If they do then wait for the overall call task
// to complete before returning headers. This means that if the call failed with a
// a status then it is possible to await response headers and then call GetStatus().
var grpcStatus = GrpcProtocolHelpers.GetHeaderValue(httpResponse.Headers, GrpcProtocolConstants.StatusTrailer);
if (grpcStatus != null)
{
await CallTask.ConfigureAwait(false);
}
return(GrpcProtocolHelpers.BuildMetadata(httpResponse.Headers));
}
catch (Exception ex) when(ResolveException(ErrorStartingCallMessage, ex, out _, out var resolvedException))
{
throw resolvedException;
}
}
