private void ProcessRequest(ref ArraySegment <byte> data)
{
var requestBuffer = data.Array !;
var requestBody = (ReadOnlySpan <byte>)data;
var ret = RequestReader.Parse(ref requestBody, BaseUri) !;
HttpRequest = ret.Item1;
ContentHeaders = ret.Item2;
Options.RequestProcessor !.Process(this, HttpRequest);
var pooledBuffer = Tunnel.ArrayPool.Rent(data.Count + 8096);
// write request back
int requestLength;
using (var memoryStream = new MemoryStream(pooledBuffer))
{
using (var streamWriter = new StreamWriter(memoryStream, leaveOpen: true))
{
RequestWriter.WriteRequest(streamWriter, HttpRequest, requestBody.Length, ContentHeaders);
}
requestLength = (int)memoryStream.Position;
}
requestBody.CopyTo(pooledBuffer.AsSpan(requestLength));
data = new(pooledBuffer, 0, requestLength + requestBody.Length);
// return current buffer
Tunnel.ArrayPool.Return(requestBuffer);
}
public void Can_manually_request_an_IRequest()
{
IRequest request = new RequestWriter("GET", "/foo");
MockResponse response = session.GetResponse(request);
Assert.That(response.BodyText, Is.EqualTo("You requested GET /foo"));
}
public void Can_make_new_with_method_and_uri_and_body_as_string()
{
request = new RequestWriter("POST", "/dogs", "name=Rover&breed=GoldenRetriever");
Assert.That(request.Method, Is.EqualTo("POST"));
Assert.That(request.Uri, Is.EqualTo("/dogs"));
Assert.That(request.Body, Is.EqualTo("name=Rover&breed=GoldenRetriever"));
}
public async Task CreateUpdateRequest_PreferredVerbPut_AllProperties_Put()
{
var preferredUpdateMethod = _session.Settings.PreferredUpdateMethod;
try
{
_session.Settings.PreferredUpdateMethod = ODataUpdateMethod.Put;
var requestWriter = new RequestWriter(_session, await _client.GetMetadataAsync <IEdmModel>(), null);
var result = await requestWriter.CreateUpdateRequestAsync("Products", "",
new Dictionary <string, object>() { { "ProductID", 1 } },
new Dictionary <string, object>()
{
{ "ProductID", 1 },
{ "SupplierID", 2 },
{ "CategoryID", 3 },
{ "ProductName", "Chai" },
{ "EnglishName", "Tea" },
{ "QuantityPerUnit", "10" },
{ "UnitPrice", 20m },
{ "UnitsInStock", 100 },
{ "UnitsOnOrder", 1000 },
{ "ReorderLevel", 500 },
{ "Discontinued", false },
}, false);
Assert.Equal("PUT", result.Method);
}
finally
{
_session.Settings.PreferredUpdateMethod = preferredUpdateMethod;
}
}
public void Can_SetItem()
{
request = new RequestWriter().SetItem("owin.num", 5).SetItem("owin.decimal", 12.34).SetItem("owin.string", "hello!");
Assert.That(request.Items["owin.num"], Is.EqualTo(5));
Assert.That(request.Items["owin.decimal"], Is.EqualTo(12.34));
Assert.That(request.Items["owin.string"], Is.EqualTo("hello!"));
}
public async Task ActionWithEnum()
{
var requestWriter = new RequestWriter(_session, await _client.GetMetadataAsync <IEdmModel>().ConfigureAwait(false), null);
var result = await requestWriter.CreateActionRequestAsync("Entity", "MakeFromParam", null,
new Dictionary <string, object>() { { "Name", "Entity Name" }, { "Rank", Rank.Second } }, false).ConfigureAwait(false);
Assert.Equal("POST", result.Method);
}
protected virtual void Dispose(bool disposing)
{
if (!_disposed && disposing)
{
RequestWriter.Dispose();
_disposed = true;
}
}
public void Can_make_new_with_method_and_uri_and_body_as_bytes()
{
byte[] bytes = Encoding.UTF8.GetBytes("Hello there!");
request = new RequestWriter("POST", "/dogs", bytes);
Assert.That(request.Method, Is.EqualTo("POST"));
Assert.That(request.Uri, Is.EqualTo("/dogs"));
Assert.That(request.BodyBytes, Is.EqualTo(bytes));
Assert.That(request.Body, Is.EqualTo("Hello there!"));
}
public void Can_AddHeader_which_adds_to_the_IEnumerable_with_IEnumerable_string()
{
request = new RequestWriter().SetHeader("content-type", new string[] { "application/json" }).SetHeader("content-type", new string[] { "application/second" });
Assert.That(request.Headers["content-type"], Is.EqualTo(new string[] { "application/second" }));
// Now use AddHeader, and both values should be present
request = new RequestWriter().SetHeader("content-type", new string[] { "application/json" }).AddHeader("content-type", new string[] { "application/second" });
Assert.That(request.Headers["content-type"], Is.EqualTo(new string[] { "application/json", "application/second" }));
}
public async Task CreateUpdateRequest_NoPreferredVerb_PartialProperties_Patch()
{
var requestWriter = new RequestWriter(_session, await _client.GetMetadataAsync <IEdmModel>(), null);
var result = await requestWriter.CreateUpdateRequestAsync("Products", "",
new Dictionary <string, object>() { { "ProductID", 1 } },
new Dictionary <string, object>() { { "ProductName", "Chai" } }, false);
Assert.Equal("PATCH", result.Method);
}
public void Can_AddToBody_with_string()
{
request = new RequestWriter().SetBody("Hi there").SetBody("override");
Assert.That(request.Body, Is.EqualTo("override"));
Assert.That(request.BodyBytes, Is.EqualTo(Encoding.UTF8.GetBytes("override")));
request = new RequestWriter().SetBody("Hi there").AddToBody("override");
Assert.That(request.Body, Is.EqualTo("Hi thereoverride"));
Assert.That(request.BodyBytes, Is.EqualTo(Encoding.UTF8.GetBytes("Hi thereoverride")));
}
public void Can_get_LastRequest()
{
Assert.Null(session.LastRequest);
IRequest request = new RequestWriter("GET", "/bar");
session.GetResponse(request);
Assert.NotNull(session.LastRequest);
Assert.That(session.LastRequest.Method, Is.EqualTo("GET"));
Assert.That(session.LastRequest.Uri, Is.EqualTo("/bar"));
}
public void Validates_incoming_Request()
{
IRequest goodRequest = new RequestWriter("GET", "/");
GetResponse(goodRequest);
Assert.That(LastResponse.BodyText, Is.EqualTo("You requested GET /"));
Assert.That(LastResponse.BodyText, Is.Not.StringContaining("LintException"));
IRequest badRequest = new RequestWriter().SetMethod(""); // blank Method
GetResponse(badRequest);
Assert.That(LastResponse.BodyText, Is.StringContaining("Owin.LintException: Request was not valid: Method cannot be blank"));
}
public void Can_AddToBody_with_bytes()
{
byte[] first = Encoding.UTF8.GetBytes("first");
byte[] second = Encoding.UTF8.GetBytes("second");
byte[] firstAndSecond = Encoding.UTF8.GetBytes("firstsecond");
request = new RequestWriter().SetBody(first).SetBody(second);
Assert.That(request.Body, Is.EqualTo("second"));
Assert.That(request.BodyBytes, Is.EqualTo(second));
request = new RequestWriter().SetBody(first).AddToBody(second);
Assert.That(request.Body, Is.EqualTo("firstsecond"));
Assert.That(request.BodyBytes, Is.EqualTo(firstAndSecond));
}
protected virtual void OnExecute(ISimoConnection connection)
{
var request = GenerateRequest();
using (var requestStream = connection.GetPipeStream())
{
using (var requestWriter = new RequestWriter(requestStream))
{
requestWriter.Write(request);
OnRequestSent();
}
}
}
public IRequest Create(Stream body)
{
var wcfRequest = WebOperationContext.Current.IncomingRequest;
var writer = new RequestWriter(wcfRequest.Method, wcfRequest.UriTemplateMatch.RequestUri.AbsoluteUri);
var buffer = new byte[body.Length];
int i = body.Read(buffer, 0, (int)body.Length);
writer.SetBody(buffer);
foreach (string header in wcfRequest.Headers.Keys)
{
writer.AddHeader(header, wcfRequest.Headers[header]);
}
var request = writer.InnerRequest;
SetItems(request.Items, WebOperationContext.Current.IncomingRequest.UriTemplateMatch);
return request;
}
private Tuple <string, string> WriteStream(object data, SerializeFormat format)
{
HttpWebRequest request = WebRequest.CreateHttp("http://www.bing.com");
RequestWriter writer = new RequestWriter(request);
using (MemoryStream ms = new MemoryStream()) {
_writeMethod.Invoke(writer, new object[] { ms, data, format });
ms.Position = 0;
return(new Tuple <string, string>(
request.ContentType,
Encoding.UTF8.GetString(ms.ToArray())
));
}
}
static void Main(string[] args)
{
var nonLockingSessionFactory = new NonLockingSessionFactory();
var sessionFactory = new SessionFactory();
var requestWriter = new RequestWriter();
var connector = new ClientConnector(nonLockingSessionFactory, requestWriter);
using (var client = new Client(connector, new TcpClientAdapter()))
{
client.Configure(new Configuration("localhost", 1491, "SecretPassword", ConnectionMode.Search));
client.Connect();
using (var session = sessionFactory.Create(client))
{
Console.WriteLine(".NET Sonic Terminal");
Console.WriteLine("Write .read to read next line from the server.");
while (true)
{
while (true)
{
Console.Write($"W > ");
var input = Console.ReadLine();
if (input.ToLower().Trim() == ".read")
{
break;
}
else if (!string.IsNullOrWhiteSpace(input))
{
session.Write(input);
break;
}
}
var response = session.Read();
Console.WriteLine($"R > {response}");
if (response.StartsWith("ENDED"))
{
break;
}
}
}
}
}
public void MemoryRequestWriterBasic()
{
var stressTester = new StressTester();
var writer = new RequestWriter(stressTester);
int requestCount = 10_000_001;
for (int i = 0; i < requestCount; i++)
{
var req = new HttpRequestData
{
TimeTakenMs = 10,
Timestamp = DateTime.Now,
Url = "http://localhost"
};
writer.Write(req);
}
Assert.IsTrue(writer.RequestsProcessed == requestCount);
Assert.IsTrue(writer.GetResults().Count == requestCount);
}
private static void PlayWithConnection()
{
using var tcpClient = new TcpClient(host, port);
var stream = tcpClient.GetStream();
var buffer = new byte[512];
using var requestWriter = new RequestWriter(stream);
var responseReader = new ResponseReader(stream);
stream.Read(buffer);
var base64Salt = new ReadOnlySpan <byte>(buffer, 64, 44);
var authRequest = new AuthRequest("user_test", "user_test", base64Salt)
{
SyncId = 1
};
requestWriter.Write(authRequest);
var authResponse = responseReader.Read();
//var selectRequest = new SelectRequest((uint)SystemSpaceE.Vspace, 0, IteratorE.All, 0U) {SyncId = 2};
//requestWriter.Write(selectRequest);
//var selectResponse = responseReader.Read();
}
public void Can_SetHeader_with_IEnumerable_string()
{
request = new RequestWriter().SetHeader("content-type", new string[] { "application/xml" });
Assert.That(request.Headers["content-type"], Is.EqualTo(new string[] { "application/xml" }));
}
public void SetHeader_automatically_lowercases_header_keys_as_required_by_the_owin_spec()
{
request = new RequestWriter().SetHeader("CONTENT-type", "application/json");
Assert.That(request.Headers["content-type"], Is.EqualTo(new string[] { "application/json" }));
}
public void Can_SetUri()
{
request = new RequestWriter().SetMethod("PUT");
Assert.That(request.Method, Is.EqualTo("PUT"));
}
public void Before()
{
request = new Owin.RequestWriter();
}
internal DuplexStream(RequestWriter p_requestWriter, ResponseReader p_responseReader)
{
RequestWriter = p_requestWriter;
ResponseReader = p_responseReader;
}
public void Can_make_new_with_just_uri_which_defaults_to_get()
{
request = new RequestWriter("/cats");
Assert.That(request.Method, Is.EqualTo("GET"));
Assert.That(request.Uri, Is.EqualTo("/cats"));
}
public void RequestPerSecondListTest()
{
var time = DateTime.UtcNow;
var requests = new List <HttpRequestData>()
{
new HttpRequestData()
{
Timestamp = time,
TimeTakenMs = 10
},
new HttpRequestData()
{
Timestamp = time.AddMilliseconds(20),
TimeTakenMs = 15
},
new HttpRequestData
{
Timestamp = time.AddMilliseconds(220),
TimeTakenMs = 15
},
new HttpRequestData
{
Timestamp = time.AddMilliseconds(1020),
TimeTakenMs = 20
},
new HttpRequestData
{
Timestamp = time.AddMilliseconds(1050),
TimeTakenMs = 20
},
new HttpRequestData
{
Timestamp = time.AddMilliseconds(1200),
TimeTakenMs = 20
},
new HttpRequestData
{
Timestamp = time.AddMilliseconds(3020),
TimeTakenMs = 20
},
new HttpRequestData
{
Timestamp = time.AddMilliseconds(3050),
TimeTakenMs = 20
},
new HttpRequestData
{
Timestamp = time.AddMilliseconds(3200),
TimeTakenMs = 20
}, new HttpRequestData
{
Timestamp = time.AddMilliseconds(3500),
TimeTakenMs = 50
}
};
var writer = new RequestWriter(null, requests);
var parser = new ResultsParser();
var res = parser.RequestsPerSecond(writer);
Assert.IsNotNull(res);
foreach (var r in res)
{
Console.WriteLine(r.Second + ": " + r.Requests);
}
}
public void Can_SetBody_with_bytes()
{
request = new RequestWriter().SetBody(Encoding.UTF8.GetBytes("Hi there"));
Assert.That(request.Body, Is.EqualTo("Hi there"));
Assert.That(request.BodyBytes, Is.EqualTo(Encoding.UTF8.GetBytes("Hi there")));
}
public void ResultsReportTimeTakenTest()
{
var time = DateTime.UtcNow;
var requests = new List <HttpRequestData>()
{
new HttpRequestData()
{
Timestamp = time,
TimeTakenMs = 10
},
new HttpRequestData()
{
Timestamp = time.AddMilliseconds(20),
TimeTakenMs = 15
},
new HttpRequestData
{
Timestamp = time.AddMilliseconds(220),
TimeTakenMs = 15
},
new HttpRequestData
{
Timestamp = time.AddMilliseconds(1020),
TimeTakenMs = 20
},
new HttpRequestData
{
Timestamp = time.AddMilliseconds(1050),
TimeTakenMs = 20
},
new HttpRequestData
{
Timestamp = time.AddMilliseconds(1200),
TimeTakenMs = 20
},
new HttpRequestData
{
Timestamp = time.AddMilliseconds(3020),
TimeTakenMs = 20
},
new HttpRequestData
{
Timestamp = time.AddMilliseconds(3050),
TimeTakenMs = 20
},
new HttpRequestData
{
Timestamp = time.AddMilliseconds(3200),
TimeTakenMs = 20
}, new HttpRequestData
{
Timestamp = time.AddMilliseconds(3500),
TimeTakenMs = 50
}
};
var timeTakenMs = 30000;
var stressTester = new StressTester();
var writer = new RequestWriter(stressTester);
writer.SetResults(requests);
var parser = new ResultsParser();
var results = parser.GetResultReport(writer, timeTakenMs, 10);
Assert.AreEqual(timeTakenMs / 1000, results.TestResult.TimeTakenSecs);
Console.WriteLine(JsonSerializationUtils.Serialize(results, false, true));
}
public void Can_make_new_with_method_and_uri()
{
request = new RequestWriter("POST", "/dogs");
Assert.That(request.Method, Is.EqualTo("POST"));
Assert.That(request.Uri, Is.EqualTo("/dogs"));
}
public void RequestSummaryTest()
{
var time = DateTime.UtcNow;
var requests = new List <HttpRequestData>()
{
new HttpRequestData()
{
Url = "http://localhost/",
Timestamp = time,
IsError = false,
TimeTakenMs = 10,
ErrorMessage = "Invalid Server Response",
StatusCode = "500"
},
new HttpRequestData()
{
Url = "http://localhost/wconnect",
Timestamp = time.AddMilliseconds(20),
IsError = false,
TimeTakenMs = 95
},
new HttpRequestData
{
Url = "http://localhost/",
Timestamp = time.AddMilliseconds(220),
IsError = false,
TimeTakenMs = 15,
ErrorMessage = "Bogus Invalid Server Response",
StatusCode = "500"
},
new HttpRequestData
{
Url = "http://localhost/",
Timestamp = time.AddMilliseconds(1020),
TimeTakenMs = 20
},
new HttpRequestData
{
Url = "http://localhost/wconnect",
Timestamp = time.AddMilliseconds(1050),
TimeTakenMs = 20
},
new HttpRequestData
{
Url = "http://localhost/",
Timestamp = time.AddMilliseconds(1200),
TimeTakenMs = 20
},
new HttpRequestData
{
Url = "http://localhost/",
Timestamp = time.AddMilliseconds(3020),
TimeTakenMs = 20
},
new HttpRequestData
{
Url = "http://localhost/",
Timestamp = time.AddMilliseconds(3050),
TimeTakenMs = 20
},
new HttpRequestData
{
Url = "http://localhost/wconnect",
Timestamp = time.AddMilliseconds(3200),
TimeTakenMs = 20
},
new HttpRequestData
{
Url = "http://localhost/wconnect",
Timestamp = time.AddMilliseconds(3500),
TimeTakenMs = 50
},
new HttpRequestData
{
Url = "http://localhost/wconnect/testpage",
Timestamp = time.AddMilliseconds(3100),
IsError = false,
TimeTakenMs = 50
},
new HttpRequestData
{
Url = "http://localhost/wconnect/testpage",
IsError = false,
Timestamp = time.AddMilliseconds(3200),
TimeTakenMs = 57
},
new HttpRequestData
{
Url = "http://localhost/wconnect/testpage2",
Timestamp = time.AddMilliseconds(3100),
TimeTakenMs = 50
},
new HttpRequestData
{
Url = "http://localhost/wconnect/testpage2",
Timestamp = time.AddMilliseconds(3200),
TimeTakenMs = 57
}
};
var writer = new RequestWriter(null, requests);
var parser = new ResultsParser();
var res = parser.UrlSummary(writer, 200);
Assert.IsNotNull(res);
Assert.IsTrue(res.Count() > 0);
foreach (var r in res)
{
Console.WriteLine(r.Url + ": " + JsonSerializationUtils.Serialize(r.Results, false, true));
}
var html = parser.GetResultReportHtml(writer, 10, 2);
Console.WriteLine(html);
var file = App.UserDataPath + "html\\_preview.html";
File.WriteAllText(file, html);
ShellUtils.GoUrl(file);
}
