public async void SmokeTest(Func <EndPoint> endpoint, int length, PipeScheduler schedulerMode, int threadCount, int ringSize, bool threadAffinity)
{
using var server = new EchoServer(endpoint(), OutputHelper);
await using var transport = new IoUringTransport(Options.Create(new IoUringOptions
{
ThreadCount = threadCount,
SetThreadAffinity = threadAffinity,
ApplicationSchedulingMode = schedulerMode,
RingSize = ringSize
}));
await using var connectionFactory = new ConnectionFactory(transport);
for (int i = 0; i < 3; i++)
{
await using var connection = await connectionFactory.ConnectAsync(server.EndPoint);
for (int j = 0; j < 3; j++)
{
await SendReceiveData(connection.Transport, length);
}
await connection.Transport.Output.CompleteAsync();
await connection.Transport.Input.CompleteAsync();
}
}
public static async ValueTask <Connection> ConnectAsync(ConnectionFactory factory, DnsEndPoint endPoint, IConnectionProperties?options, CancellationToken cancellationToken)
{
try
{
return(await factory.ConnectAsync(endPoint, options, cancellationToken).ConfigureAwait(false));
}
catch (OperationCanceledException ex) when(ex.CancellationToken == cancellationToken)
{
throw CancellationHelper.CreateOperationCanceledException(innerException: null, cancellationToken);
}
catch (Exception ex)
{
throw CreateWrappedException(ex, endPoint.Host, endPoint.Port, cancellationToken);
}
}
public Task <ConnectionContext> ConnectAsync(HubServiceEndpoint endpoint, TransferFormat transferFormat, string connectionId, string target, CancellationToken cancellationToken = default, IDictionary <string, string> headers = null)
{
if (headers == null)
{
headers = new Dictionary <string, string> {
{ Constants.AsrsUserAgent, _productInfo }
};
}
else
{
headers[Constants.AsrsUserAgent] = _productInfo;
}
return(_connectionFactory.ConnectAsync(endpoint, transferFormat, connectionId, target, cancellationToken, headers));
}
public async Task <StringsModel> LoadAsync(StringsModel stringsModel)
{
using SqliteConnection connection = await ConnectionFactory.ConnectAsync();
SqliteCommand query = connection.CreateCommand();
query.CommandText = "select String from Strings where Identifier = @Identifier and Locale = @Locale";
query.Parameters.AddWithValue("@Identifier", stringsModel.Identifier);
query.Parameters.AddWithValue("@Locale", stringsModel.Locale);
SqliteDataReader reader = await query.ExecuteReaderAsync();
if (await reader.ReadAsync())
{
stringsModel.String = (string)reader["String"];
}
return(stringsModel);
}
public async Task <ShibaConfigModel> LoadAsync()
{
_connection = await ConnectionFactory.ConnectAsync();
SqliteCommand query = _connection.CreateCommand();
query.CommandText += "select * from ShibaConfig;";
SqliteDataReader reader = await query.ExecuteReaderAsync();
ShibaConfigModel shibaConfig = null;
if (await reader.ReadAsync())
{
shibaConfig = new ShibaConfigModel(Convert.ToUInt64(reader["OwnerID"]), reader["Token"].ToString(), reader["MongoConnectionString"].ToString());
}
await _connection.CloseAsync();
await _connection.DisposeAsync();
return(shibaConfig);
}
public override async ValueTask ProcessAsync(HttpMessage message)
{
var pipelineRequest = message.Request;
var host = pipelineRequest.Uri.Host;
HttpMethod method = MapMethod(pipelineRequest.Method);
Connection connection = await connectionFactory.ConnectAsync(new DnsEndPoint(host, 80));
HttpConnection httpConnection = new Http1Connection(connection, HttpPrimitiveVersion.Version11);
await using (ValueHttpRequest request = (await httpConnection.CreateNewRequestAsync(HttpPrimitiveVersion.Version11, HttpVersionPolicy.RequestVersionExact)).Value) {
RequestContent pipelineContent = pipelineRequest.Content;
long contentLength = 0;
if (pipelineContent != null)
{
if (!pipelineContent.TryComputeLength(out contentLength))
{
throw new NotImplementedException();
}
}
request.ConfigureRequest(contentLength: contentLength, hasTrailingHeaders: false);
request.WriteRequest(method, pipelineRequest.Uri.ToUri());
var pipelineHeaders = pipelineRequest.Headers;
foreach (var header in pipelineHeaders)
{
request.WriteHeader(header.Name, header.Value);
}
checked {
if (contentLength != 0)
{
using var ms = new MemoryStream((int)contentLength); // TODO: can the buffer be disposed here?
await pipelineContent.WriteToAsync(ms, message.CancellationToken);
await request.WriteContentAsync(ms.GetBuffer().AsMemory(0, (int)ms.Length));
}
}
await request.CompleteRequestAsync();
var response = new NoAllocResponse();
message.Response = response;
await request.ReadToFinalResponseAsync();
response.SetStatus((int)request.StatusCode);
if (await request.ReadToHeadersAsync())
{
await request.ReadHeadersAsync(response, state : null);
}
if (await request.ReadToContentAsync())
{
var buffer = new byte[4096];
int readLen;
do
{
while ((readLen = await request.ReadContentAsync(buffer)) != 0)
{
if (readLen < 4096)
{
response.ContentStream = new MemoryStream(buffer, 0, readLen);
}
else
{
throw new NotImplementedException();
}
}
}while (await request.ReadToNextContentAsync());
}
if (await request.ReadToTrailingHeadersAsync())
{
await request.ReadHeadersAsync(response, state : null);
}
}
}
