private static Request CreateRequest(HttpClientTransport transport, byte[] bytes = null)
{
Request request = transport.CreateRequest();
request.Method = RequestMethod.Get;
request.Uri.Reset(new Uri("https://example.com:340"));
request.Content = RequestContent.Create(bytes ?? Array.Empty <byte>());
return(request);
}
public HttpClientTransport GetTransport()
{
var transport = new HttpClientTransport(new HttpClient(new HttpClientHandler()
{
ServerCertificateCustomValidationCallback = HttpClientHandler.DangerousAcceptAnyServerCertificateValidator
}));
return(transport);
}
protected static async Task <Response> ExecuteRequest(Request request, HttpClientTransport transport)
{
var message = new HttpPipelineMessage(request, new ResponseClassifier(), CancellationToken.None)
{
Request = request
};
await transport.ProcessAsync(message);
return(message.Response);
}
/// <summary>
/// Initializes a new instance of the PCHCClient class
/// With the specified http transport type, server name, linsten port number and resource.
/// </summary>
/// <param name="httpTransportType">Http transport type.</param>
/// <param name="serverName">The server name.</param>
/// <param name="port">The listening port.</param>
/// <param name="resource">The resource.</param>
/// <param name="domainName">The domain name.</param>
/// <param name="userName">The user name.</param>
/// <param name="userPassword">The password.</param>
public PCHCClient(TransferProtocol httpTransportType, string serverName, int port, string resource, string domainName, string userName, string userPassword)
{
if (httpTransportType != TransferProtocol.HTTP && httpTransportType != TransferProtocol.HTTPS)
{
throw new ArgumentException(
"httpTransportType contains invalid not supported transport type", "httpTransportType");
}
this.httpClientTransport = new HttpClientTransport(httpTransportType, serverName, port, resource, domainName, userName, userPassword);
}
public void TryGetReturnsCorrectValuesWhenNotFound(string headerName, string headerValue, bool contentHeader)
{
var transport = new HttpClientTransport();
Request request = CreateRequest(transport);
Assert.False(request.Headers.TryGetValue(headerName, out string value));
Assert.IsNull(value);
Assert.False(request.Headers.TryGetValues(headerName, out IEnumerable <string> values));
Assert.IsNull(values);
}
protected static async Task <Response> ExecuteRequest(Request request, HttpClientTransport transport)
{
using (var message = new HttpPipelineMessage(CancellationToken.None)
{
Request = request
})
{
await transport.ProcessAsync(message);
return(message.Response);
}
}
public async Task RequestIdCanBeOverriden()
{
var mockHandler = new MockHttpClientHandler(httpRequestMessage => { });
var transport = new HttpClientTransport(new HttpClient(mockHandler));
var request = transport.CreateRequest(null);
request.RequestId = "123";
request.SetRequestLine(HttpPipelineMethod.Get, new Uri("http://example.com:340"));
var response = await ExecuteRequest(request, transport);
Assert.AreEqual(request.RequestId, response.RequestId);
}
static unsafe AppHandle()
{
NativeCommon.Initialize();
SessionHandle.InstallCallbacks();
NativeMethods.LogMessageCallback logMessage = HandleLogMessage;
NativeMethods.UserCallback userLogin = HandleUserCallback;
NativeMethods.VoidTaskCallback taskCallback = HandleTaskCompletion;
NativeMethods.BsonCallback bsonCallback = HandleBsonCallback;
GCHandle.Alloc(logMessage);
GCHandle.Alloc(userLogin);
GCHandle.Alloc(taskCallback);
GCHandle.Alloc(bsonCallback);
//// This is a hack due to a mixup of what OS uses as platform/SDK and what is displayed in the UI.
//// The original code is below:
////
//// string platform;
//// string platformVersion;
//// var platformRegex = new Regex("^(?<platform>[^0-9]*) (?<version>[^ ]*)", RegexOptions.Compiled);
//// var osDescription = platformRegex.Match(RuntimeInformation.OSDescription);
//// if (osDescription.Success)
//// {
//// platform = osDescription.Groups["platform"].Value;
//// platformVersion = osDescription.Groups["version"].Value;
//// }
//// else
//// {
//// platform = Environment.OSVersion.Platform.ToString();
//// platformVersion = Environment.OSVersion.VersionString;
//// }
var platform = "Realm .NET";
var platformVersion = RuntimeInformation.OSDescription;
// var sdkVersion = typeof(AppHandle).GetTypeInfo().Assembly.GetName().Version.ToString(3);
// TODO: temporarily add -beta.X suffix to the SDK
var sdkVersion = "10.0.0-beta.6";
NativeMethods.initialize(
platform, (IntPtr)platform.Length,
platformVersion, (IntPtr)platformVersion.Length,
sdkVersion, (IntPtr)sdkVersion.Length,
userLogin, taskCallback, bsonCallback, logMessage);
HttpClientTransport.Install();
}
public async Task SettingContentHeaderDoesNotSetContent(string headerName, string headerValue, bool contentHeader)
{
HttpContent httpMessageContent = null;
var mockHandler = new MockHttpClientHandler(httpRequestMessage => { httpMessageContent = httpRequestMessage.Content; });
var transport = new HttpClientTransport(new HttpClient(mockHandler));
var request = transport.CreateRequest(null);
request.SetRequestLine(HttpPipelineMethod.Get, new Uri("http://example.com:340"));
request.Headers.Add(headerName, headerValue);
await ExecuteRequest(request, transport);
Assert.Null(httpMessageContent);
}
public async Task RequestIdCanBeOverriden()
{
var mockHandler = new MockHttpClientHandler(httpRequestMessage => { });
var transport = new HttpClientTransport(new HttpClient(mockHandler));
Request request = transport.CreateRequest();
request.ClientRequestId = "123";
request.Method = RequestMethod.Get;
request.Uri.Reset(new Uri("https://example.com:340"));
Response response = await ExecuteRequest(request, transport);
Assert.AreEqual(request.ClientRequestId, response.ClientRequestId);
}
public async Task RequestAndResponseHasRequestId()
{
var mockHandler = new MockHttpClientHandler(httpRequestMessage => { });
var transport = new HttpClientTransport(new HttpClient(mockHandler));
var request = transport.CreateRequest(null);
Assert.IsNotEmpty(request.RequestId);
Assert.True(Guid.TryParse(request.RequestId, out _));
request.SetRequestLine(HttpPipelineMethod.Get, new Uri("http://example.com:340"));
var response = await ExecuteRequest(request, transport);
Assert.AreEqual(request.RequestId, response.RequestId);
}
/// <summary>
/// Initializes a new instance of the <see cref="CallingServerClientOptions"/>.
/// </summary>
public CallingServerClientOptions(ServiceVersion version = LatestVersion, bool allowAutoRedirect = false)
{
AllowAutoRedirect = allowAutoRedirect;
ApiVersion = version switch
{
ServiceVersion.V2021_06_15_Preview => "2021-06-15-preview",
_ => throw new ArgumentOutOfRangeException(nameof(version)),
};
var clientHandler = new HttpClientHandler()
{
AllowAutoRedirect = allowAutoRedirect
};
Transport = new HttpClientTransport(clientHandler);
}
/// <summary>
/// Release resources.
/// </summary>
/// <param name="disposing">If disposing equals true, Managed and unmanaged resources are disposed.
/// if false, Only unmanaged resources can be disposed.</param>
protected virtual void Dispose(bool disposing)
{
if (!this.disposed)
{
if (disposing)
{
if (this.httpClientTransport != null)
{
this.httpClientTransport.Dispose();
this.httpClientTransport = null;
}
}
this.disposed = true;
}
}
public async Task RequestAndResponseHasRequestId()
{
var mockHandler = new MockHttpClientHandler(httpRequestMessage => { });
var transport = new HttpClientTransport(new HttpClient(mockHandler));
Request request = transport.CreateRequest();
Assert.IsNotEmpty(request.ClientRequestId);
Assert.True(Guid.TryParse(request.ClientRequestId, out _));
request.Method = RequestMethod.Get;
request.UriBuilder.Uri = new Uri("https://example.com:340");
Response response = await ExecuteRequest(request, transport);
Assert.AreEqual(request.ClientRequestId, response.ClientRequestId);
}
public void TransportExceptionsAreWrapped()
{
using (TestServer testServer = new TestServer(
context =>
{
context.Abort();
return(Task.CompletedTask);
}))
{
var transport = new HttpClientTransport();
Request request = transport.CreateRequest();
request.Uri.Reset(testServer.Address);
RequestFailedException exception = Assert.ThrowsAsync <RequestFailedException>(async() => await ExecuteRequest(request, transport));
Assert.AreEqual("An error occurred while sending the request.", exception.Message);
}
}
public void AspNetCoreShouldBeOperational()
{
var builder = new WebHostBuilder()
.UseKestrel()
.UseStartup <Startup>();
var host = builder.Build();
host.Start();
var address = host.ServerFeatures.Get <IServerAddressesFeature>();
var addr = address.Addresses.First().ToString();
var transport = new HttpClientTransport(addr + "/rpc");
var resp = transport.SendMessageAsync(new byte[] { 1, 2 }).Result;
Assert.True(resp.SequenceEqual(new byte[] { 2, 1 }));
host.Services.GetService <IApplicationLifetime>().StopApplication();
}
static unsafe AppHandle()
{
NativeCommon.Initialize();
SessionHandle.InstallCallbacks();
NativeMethods.LogMessageCallback logMessage = HandleLogMessage;
NativeMethods.UserCallback userLogin = HandleUserCallback;
NativeMethods.VoidTaskCallback taskCallback = HandleTaskCompletion;
NativeMethods.BsonCallback bsonCallback = HandleBsonCallback;
GCHandle.Alloc(logMessage);
GCHandle.Alloc(userLogin);
GCHandle.Alloc(taskCallback);
GCHandle.Alloc(bsonCallback);
//// This is a hack due to a mixup of what OS uses as platform/SDK and what is displayed in the UI.
//// The original code is below:
////
//// string platform;
//// string platformVersion;
//// var platformRegex = new Regex("^(?<platform>[^0-9]*) (?<version>[^ ]*)", RegexOptions.Compiled);
//// var osDescription = platformRegex.Match(RuntimeInformation.OSDescription);
//// if (osDescription.Success)
//// {
//// platform = osDescription.Groups["platform"].Value;
//// platformVersion = osDescription.Groups["version"].Value;
//// }
//// else
//// {
//// platform = Environment.OSVersion.Platform.ToString();
//// platformVersion = Environment.OSVersion.VersionString;
//// }
var platform = InteropConfig.Platform;
var platformVersion = RuntimeInformation.OSDescription;
// TODO: temp - remove that once we're out of beta
var sdkVersion = "10.2.0-beta.2"; // InteropConfig.SDKVersion.ToString(3);
NativeMethods.initialize(
platform, platform.IntPtrLength(),
platformVersion, platformVersion.IntPtrLength(),
sdkVersion, sdkVersion.IntPtrLength(),
userLogin, taskCallback, bsonCallback, logMessage);
HttpClientTransport.Install();
}
/// <summary>
/// Initializes a new instance of the PCHCClient class
/// With the specified http transport type, server name, linsten port number and resource.
/// </summary>
/// <param name="httpTransportType">Http transport type.</param>
/// <param name="serverName">The server name.</param>
/// <param name="port">The listening port.</param>
/// <param name="resource">The resource.</param>
/// <param name="logger">The logger.</param>
public PCHCClient(TransferProtocol httpTransportType, string serverName, int port, string resource, ILogPrinter logger)
{
if (logger == null)
{
throw new ArgumentNullException("logger", "The input parameter \"logger\" is null.");
}
this.logger = logger;
if (httpTransportType != TransferProtocol.HTTP && httpTransportType != TransferProtocol.HTTPS)
{
throw new ArgumentException(
"httpTransportType contains invalid not supported transport type", "httpTransportType");
}
this.httpClientTransport = new HttpClientTransport(httpTransportType, serverName, port, resource, logger);
}
public async Task ContentLengthIsSetForArrayContent(HttpPipelineRequestContent content, int expectedLength)
{
long contentLength = 0;
var mockHandler = new MockHttpClientHandler(
httpRequestMessage => contentLength = httpRequestMessage.Content.Headers.ContentLength.Value
);
var transport = new HttpClientTransport(new HttpClient(mockHandler));
var request = transport.CreateRequest(null);
request.SetRequestLine(HttpPipelineMethod.Get, new Uri("http://example.com"));
request.Content = content;
await ExecuteRequest(request, transport);
Assert.AreEqual(expectedLength, contentLength);
}
public async Task ReasonPhraseIsExposed()
{
var httpResponseMessage = new HttpResponseMessage(HttpStatusCode.OK)
{
ReasonPhrase = "Custom ReasonPhrase"
};
var mockHandler = new MockHttpClientHandler(httpRequestMessage => Task.FromResult(httpResponseMessage));
var transport = new HttpClientTransport(new HttpClient(mockHandler));
Request request = transport.CreateRequest();
request.SetRequestLine(HttpPipelineMethod.Get, new Uri("http://example.com:340"));
Response response = await ExecuteRequest(request, transport);
Assert.AreEqual("Custom ReasonPhrase", response.ReasonPhrase);
}
public async Task SettingHeaderOverridesDefaultContentLength()
{
long contentLength = 0;
var mockHandler = new MockHttpClientHandler(
httpRequestMessage => contentLength = httpRequestMessage.Content.Headers.ContentLength.Value);
var transport = new HttpClientTransport(new HttpClient(mockHandler));
var request = transport.CreateRequest(null);
request.SetRequestLine(HttpPipelineMethod.Get, new Uri("http://example.com"));
request.Content = HttpPipelineRequestContent.Create(new byte[10]);
request.Headers.Add("Content-Length", "50");
await ExecuteRequest(request, transport);
Assert.AreEqual(50, contentLength);
}
public async Task SettingHeaderOverridesDefaultHost()
{
string host = null;
var mockHandler = new MockHttpClientHandler(
httpRequestMessage => {
host = httpRequestMessage.Headers.Host;
});
var transport = new HttpClientTransport(new HttpClient(mockHandler));
var request = transport.CreateRequest(null);
request.SetRequestLine(HttpPipelineMethod.Get, new Uri("http://example.com:340"));
request.Headers.Add("Host", "example.org");
await ExecuteRequest(request, transport);
Assert.AreEqual("example.org", host);
}
public async Task CanGetAndSetMultiValueResponseHeaders(string headerName, string headerValue, bool contentHeader)
{
var anotherHeaderValue = headerValue + "1";
var joinedHeaderValues = headerValue + "," + anotherHeaderValue;
var mockHandler = new MockHttpClientHandler(
httpRequestMessage =>
{
var responseMessage = new HttpResponseMessage((HttpStatusCode)200);
if (contentHeader)
{
responseMessage.Content = new StreamContent(new MemoryStream());
Assert.True(responseMessage.Content.Headers.TryAddWithoutValidation(headerName, headerValue));
Assert.True(responseMessage.Content.Headers.TryAddWithoutValidation(headerName, anotherHeaderValue));
}
else
{
Assert.True(responseMessage.Headers.TryAddWithoutValidation(headerName, headerValue));
Assert.True(responseMessage.Headers.TryAddWithoutValidation(headerName, anotherHeaderValue));
}
return(Task.FromResult(responseMessage));
});
var transport = new HttpClientTransport(new HttpClient(mockHandler));
Request request = transport.CreateRequest();
request.Method = RequestMethod.Get;
request.Uri.Reset(new Uri("https://example.com:340"));
Response response = await ExecuteRequest(request, transport);
Assert.True(response.Headers.Contains(headerName));
Assert.True(response.Headers.TryGetValue(headerName, out var value));
Assert.AreEqual(joinedHeaderValues, value);
Assert.True(response.Headers.TryGetValues(headerName, out IEnumerable <string> values));
CollectionAssert.AreEqual(new[] { headerValue, anotherHeaderValue }, values);
CollectionAssert.Contains(response.Headers, new HttpHeader(headerName, joinedHeaderValues));
}
/// <summary>
/// Send HTTP request for the full content and receive HTTP response from the server.
/// </summary>
/// <param name="httpVersion">he HTTP version.</param>
/// <param name="request">The HTTP reqeust.</param>
/// <param name="timeOut">The time out to wait the response.</param>
/// <returns>Returns the recieved HTTP response.</returns>
public PccrtpResponse SendHttpRequest(
HttpVersionType httpVersion,
PccrtpRequest request,
int timeOut)
{
byte[] payloadBuffer = null;
if (this.logger != null)
{
this.httpClientTransport = new HttpClientTransport(
TransferProtocol.HTTP,
request.ServerAddress,
request.Port,
request.RequestFileName,
this.logger);
}
else
{
this.httpClientTransport = new HttpClientTransport(
TransferProtocol.HTTP,
request.ServerAddress,
request.Port,
request.RequestFileName);
}
if (HttpVersionType.HttpVersion10 == (HttpVersionType)httpVersion)
{
this.httpClientTransport.Send(HttpVersion.Version10, request.HttpHeader, null, HttpMethod.GET, timeOut);
}
else
{
// The default version of HTTP to use for the request is HTTP 1.1.
this.httpClientTransport.Send(HttpVersion.Version11, request.HttpHeader, null, HttpMethod.GET, timeOut);
}
this.httpWebResponse = this.httpClientTransport.Receive(ref payloadBuffer);
this.pccrtpResponse.DecodeHttpHeader(this.httpWebResponse);
this.pccrtpResponse.PayloadData = payloadBuffer;
this.pccrtpResponse.HttpResponse = this.httpWebResponse;
return(this.pccrtpResponse);
}
public async Task CanGetAndSetMethod(HttpPipelineMethod method, string expectedMethod)
{
HttpMethod httpMethod = null;
var mockHandler = new MockHttpClientHandler(
httpRequestMessage => {
httpMethod = httpRequestMessage.Method;
});
var transport = new HttpClientTransport(new HttpClient(mockHandler));
var request = transport.CreateRequest(null);
request.SetRequestLine(method, new Uri("http://example.com:340"));
Assert.AreEqual(method, request.Method);
await ExecuteRequest(request, transport);
Assert.AreEqual(expectedMethod, httpMethod.Method);
}
public async Task ResponseHeadersAreSplit()
{
using (TestServer testServer = new TestServer(
async context =>
{
context.Response.Headers.Add("Sync-Token", new[] { "A", "B" });
byte[] buffer = Encoding.UTF8.GetBytes("Hello");
await context.Response.Body.WriteAsync(buffer, 0, buffer.Length);
}))
{
var transport = new HttpClientTransport();
Request request = transport.CreateRequest();
request.UriBuilder.Uri = testServer.Address;
Response response = await ExecuteRequest(request, transport);
Assert.True(response.Headers.TryGetValues("Sync-Token", out var tokens));
Assert.AreEqual(2, tokens.Count());
CollectionAssert.AreEqual(new[] { "A", "B" }, tokens);
}
}
/// <summary>
/// Dispose(bool disposing) executes in two distinct scenarios.
/// If disposing equals true, the method has been called directly
/// or indirectly by a user's code. Managed and unmanaged resources
/// can be disposed.
/// If disposing equals false, the method has been called by the
/// runtime from inside the finalizer and you should not reference
/// other objects. Only unmanaged resources can be disposed
/// </summary>
/// <param name="disposing">Specify which scenario is used.</param>
private void Dispose(bool disposing)
{
// Check to see if Dispose has already been called.
if (!this.disposed)
{
// If disposing equals true, dispose all managed
// and unmanaged resources.
if (disposing)
{
if (this.httpClientTransport != null)
{
this.httpClientTransport.Dispose();
this.httpClientTransport = null;
}
}
}
// Note disposing has been done.
this.disposed = true;
}
/// <summary>
/// Release resources.
/// </summary>
/// <param name = "disposing">
/// If disposing equals true, managed and unmanaged resources are disposed.
/// If false, only unmanaged resources can be disposed.
/// </param>
protected virtual void Dispose(bool disposing)
{
if (!this.disposed)
{
// If disposing equals true, dispose all managed and unmanaged resources.
if (disposing)
{
// Free managed resources & other reference types:
if (this.httpClientTransport != null)
{
this.httpClientTransport.Dispose();
this.httpClientTransport = null;
}
}
// Call the appropriate methods to clean up unmanaged resources.
// If disposing is false, only the following code is executed:
this.disposed = true;
}
}
public async Task ResponseHeadersAreNotSplit()
{
using (TestServer testServer = new TestServer(
async context =>
{
context.Response.Headers.Add("Sync-Token", "A,B");
byte[] buffer = Encoding.UTF8.GetBytes("Hello");
await context.Response.Body.WriteAsync(buffer, 0, buffer.Length);
}))
{
var transport = new HttpClientTransport();
Request request = transport.CreateRequest();
request.Uri.Reset(testServer.Address);
Response response = await ExecuteRequest(request, transport);
Assert.True(response.Headers.TryGetValues("Sync-Token", out System.Collections.Generic.IEnumerable <string> tokens));
Assert.AreEqual(1, tokens.Count());
CollectionAssert.AreEqual(new[] { "A,B" }, tokens);
}
}
public async Task CanGetAndSetUri()
{
Uri requestUri = null;
var mockHandler = new MockHttpClientHandler(
httpRequestMessage => {
requestUri = httpRequestMessage.RequestUri;
});
var expectedUri = new Uri("http://example.com:340");
var transport = new HttpClientTransport(new HttpClient(mockHandler));
var request = transport.CreateRequest(null);
request.SetRequestLine(HttpPipelineMethod.Get, expectedUri);
Assert.AreEqual(expectedUri.ToString(), request.UriBuilder.ToString());
await ExecuteRequest(request, transport);
Assert.AreEqual(expectedUri, requestUri);
}
