public HttpAuthHeaders BuildAuthHeaders()
{
var authCookieData = "I can access this";
var authCookieDataBytes = Encoding.UTF8.GetBytes(authCookieData);
var authCookieDataEncrypted = SymmetricEncryptor.Encrypt(encryptionAlgorithm, encryptionKey, authCookieDataBytes);
var authCookieDataEncoded = Base64UrlEncoder.ToBase64String(authCookieDataEncrypted);
var cookies = new Dictionary <string, string>
{
{ cookieName, authCookieDataEncoded }
};
var cookieHeaderValue = CookieParser.CookiesToString(cookies);
var headers = new HttpAuthHeaders
{
{ cookieHeader, new List <string>()
{
cookieHeaderValue
} }
};
return(headers);
}
public static int BufferHeader(Memory <byte> buffer, string providerType, ContentType?contentType, string origin, HttpAuthHeaders authHeaders)
{
var headerBuffer = new ByteWriter(buffer.Span, encoding);
headerBuffer.Write(okHeaderBytes);
headerBuffer.Write(newLineBytes);
if (!String.IsNullOrWhiteSpace(providerType))
{
var providerTypeBytes = encoding.GetBytes(providerType);
headerBuffer.Write(providerTypeHeaderBytes);
headerBuffer.Write(providerTypeBytes);
headerBuffer.Write(newLineBytes);
}
if (contentType.HasValue)
{
switch (contentType.Value)
{
case ContentType.Bytes:
headerBuffer.Write(contentTypeBytesHeaderBytes);
break;
case ContentType.Json:
headerBuffer.Write(contentTypeJsonHeaderBytes);
break;
case ContentType.JsonNameless:
headerBuffer.Write(contentTypeJsonNamelessHeaderBytes);
break;
default:
throw new NotImplementedException();
}
headerBuffer.Write(newLineBytes);
}
if (authHeaders != null)
{
foreach (var authHeader in authHeaders)
{
foreach (var authHeaderValue in authHeader.Value)
{
headerBuffer.Write(encoding.GetBytes(authHeader.Key));
headerBuffer.Write(headerSplitBytes);
headerBuffer.Write(encoding.GetBytes(authHeaderValue));
headerBuffer.Write(newLineBytes);
}
}
}
if (!String.IsNullOrWhiteSpace(origin))
{
var allowOriginBytes = encoding.GetBytes(origin);
headerBuffer.Write(corsAllowOriginHeadersBytes);
headerBuffer.Write(allowOriginBytes);
headerBuffer.Write(newLineBytes);
}
else
{
headerBuffer.Write(corsAllOriginsHeadersBytes);
headerBuffer.Write(newLineBytes);
}
headerBuffer.Write(corsAllowHeadersBytes);
headerBuffer.Write(newLineBytes);
headerBuffer.Write(transferEncodingChunckedBytes);
headerBuffer.Write(newLineBytes);
headerBuffer.Write(newLineBytes);
return(headerBuffer.Position);
}
protected override async Task DispatchInternal(ICommand command, bool messageAwait)
{
var messageType = command.GetType();
var messageTypeName = messageType.GetNiceName();
var messageData = System.Text.Json.JsonSerializer.Serialize(command, messageType);
var data = new CQRSRequestData()
{
MessageType = messageTypeName,
MessageData = messageData,
MessageAwait = messageAwait
};
HttpAuthHeaders authHeaders = null;
switch (networkType)
{
case NetworkType.Internal:
data.AddClaims();
break;
case NetworkType.Api:
if (apiAuthorizer != null)
{
authHeaders = apiAuthorizer.BuildAuthHeaders();
}
break;
default:
throw new NotImplementedException();
}
var stopwatch = Stopwatch.StartNew();
var client = new TcpClient(endpoint.AddressFamily);
client.NoDelay = true;
var bufferOwner = BufferArrayPool <byte> .Rent(HttpCommon.BufferLength);
var buffer = bufferOwner.AsMemory();
Stream stream = null;
Stream requestBodyStream = null;
Stream responseBodyStream = null;
try
{
await client.ConnectAsync(endpoint.Address, endpoint.Port);
stream = client.GetStream();
//Request Header
var requestHeaderLength = HttpCommon.BufferHeader(buffer, data.ProviderType, contentType, serviceUrl, authHeaders);
#if NETSTANDARD2_0
await stream.WriteAsync(bufferOwner, 0, requestHeaderLength);
#else
await stream.WriteAsync(buffer.Slice(0, requestHeaderLength));
#endif
requestBodyStream = new HttpProtocolBodyStream(null, stream, null, true);
await ContentTypeSerializer.SerializeAsync(contentType, requestBodyStream, data);
await requestBodyStream.FlushAsync();
#if NETSTANDARD2_0
requestBodyStream.Dispose();
#else
await requestBodyStream.DisposeAsync();
#endif
requestBodyStream = null;
//Response Header
var headerPosition = 0;
var headerLength = 0;
var headerEnd = false;
while (!headerEnd)
{
if (headerLength == buffer.Length)
{
throw new Exception($"{nameof(HttpCQRSClient)} Header Too Long");
}
#if NETSTANDARD2_0
var bytesRead = await stream.ReadAsync(bufferOwner, headerPosition, buffer.Length - headerPosition);
#else
var bytesRead = await stream.ReadAsync(buffer.Slice(headerPosition, buffer.Length - headerPosition));
#endif
if (bytesRead == 0)
{
throw new EndOfStreamException();
}
headerLength += bytesRead;
headerEnd = HttpCommon.ReadToHeaderEnd(buffer, ref headerPosition, headerLength);
}
var responseHeader = HttpCommon.ReadHeader(buffer, headerPosition, headerLength);
//Response Body
responseBodyStream = new HttpProtocolBodyStream(null, stream, responseHeader.BodyStartBuffer, false);
if (responseHeader.IsError)
{
var responseException = await ContentTypeSerializer.DeserializeExceptionAsync(contentType, responseBodyStream);
throw responseException;
}
#if NETSTANDARD2_0
responseBodyStream.Dispose();
#else
await responseBodyStream.DisposeAsync();
#endif
client.Dispose();
stopwatch.Stop();
_ = Log.TraceAsync($"{nameof(HttpCQRSClient)}Sent: {messageTypeName} {stopwatch.ElapsedMilliseconds}");
}
catch
{
if (responseBodyStream != null)
{
#if NETSTANDARD2_0
responseBodyStream.Dispose();
#else
await responseBodyStream.DisposeAsync();
#endif
}
if (requestBodyStream != null)
{
#if NETSTANDARD2_0
requestBodyStream.Dispose();
#else
await requestBodyStream.DisposeAsync();
#endif
}
if (stream != null)
{
#if NETSTANDARD2_0
stream.Dispose();
#else
await stream.DisposeAsync();
#endif
}
client.Dispose();
throw;
}
finally
{
BufferArrayPool <byte> .Return(bufferOwner);
}
}
protected override TReturn CallInternal <TReturn>(bool isStream, Type interfaceType, string methodName, object[] arguments)
{
var data = new CQRSRequestData()
{
ProviderType = interfaceType.Name,
ProviderMethod = methodName
};
data.AddProviderArguments(arguments);
HttpAuthHeaders authHeaders = null;
switch (networkType)
{
case NetworkType.Internal:
data.AddClaims();
break;
case NetworkType.Api:
if (apiAuthorizer != null)
{
authHeaders = apiAuthorizer.BuildAuthHeaders();
}
break;
default:
throw new NotImplementedException();
}
var stopwatch = Stopwatch.StartNew();
var client = new TcpClient(endpoint.AddressFamily);
client.NoDelay = true;
var bufferOwner = BufferArrayPool <byte> .Rent(HttpCommon.BufferLength);
var buffer = bufferOwner.AsMemory();
Stream stream = null;
Stream requestBodyStream = null;
Stream responseBodyStream = null;
try
{
client.Connect(endpoint.Address, endpoint.Port);
stream = client.GetStream();
//Request Header
var requestHeaderLength = HttpCommon.BufferHeader(buffer, data.ProviderType, contentType, serviceUrl, authHeaders);
#if NETSTANDARD2_0
stream.Write(bufferOwner, 0, requestHeaderLength);
#else
stream.Write(buffer.Span.Slice(0, requestHeaderLength));
#endif
requestBodyStream = new HttpProtocolBodyStream(null, stream, null, true);
ContentTypeSerializer.Serialize(contentType, requestBodyStream, data);
requestBodyStream.Flush();
requestBodyStream.Dispose();
requestBodyStream = null;
//Response Header
var headerPosition = 0;
var headerLength = 0;
var headerEnd = false;
while (!headerEnd)
{
if (headerLength == buffer.Length)
{
throw new Exception($"{nameof(HttpCQRSClient)} Header Too Long");
}
#if NETSTANDARD2_0
var bytesRead = stream.Read(bufferOwner, headerPosition, buffer.Length - headerPosition);
#else
var bytesRead = stream.Read(buffer.Span.Slice(headerPosition, buffer.Length - headerPosition));
#endif
if (bytesRead == 0)
{
throw new EndOfStreamException();
}
headerLength += bytesRead;
headerEnd = HttpCommon.ReadToHeaderEnd(buffer, ref headerPosition, headerLength);
}
var responseHeader = HttpCommon.ReadHeader(buffer, headerPosition, headerLength);
//Response Body
responseBodyStream = new HttpProtocolBodyStream(null, stream, responseHeader.BodyStartBuffer, false);
if (responseHeader.IsError)
{
var responseException = ContentTypeSerializer.DeserializeException(contentType, responseBodyStream);
throw responseException;
}
stopwatch.Stop();
_ = Log.TraceAsync($"{nameof(HttpCQRSClient)} Query: {interfaceType.GetNiceName()}.{data.ProviderMethod} {stopwatch.ElapsedMilliseconds}");
if (isStream)
{
return((TReturn)(object)responseBodyStream);
}
else
{
var model = ContentTypeSerializer.Deserialize <TReturn>(contentType, responseBodyStream);
responseBodyStream.Dispose();
client.Dispose();
return(model);
}
}
catch
{
if (responseBodyStream != null)
{
responseBodyStream.Dispose();
}
if (requestBodyStream != null)
{
requestBodyStream.Dispose();
}
if (stream != null)
{
stream.Dispose();
}
client.Dispose();
throw;
}
finally
{
BufferArrayPool <byte> .Return(bufferOwner);
}
}
