/// <summary>
/// Initializes a new instance of the <see cref="Request"/> class.
/// </summary>
/// <param name="method">The HTTP data transfer method used by the client.</param>
/// <param name="uri">The absolute path of the requested resource. This shold not not include the scheme, host name, or query portion of the URI</param>
/// <param name="headers">The headers that was passed in by the client.</param>
/// <param name="body">The <see cref="Stream"/> that represents the incoming HTTP body.</param>
/// <param name="protocol">The HTTP protocol that was used by the client.</param>
/// <param name="query">The querystring data that was sent by the client.</param>
public Request(string method, string uri, IDictionary<string, IEnumerable<string>> headers, RequestStream body, string protocol, string query = "")
{
if (method == null)
throw new ArgumentNullException("method", "The value of the method parameter cannot be null.");
if (method.Length == 0)
throw new ArgumentOutOfRangeException("method", method, "The value of the method parameter cannot be empty.");
if (uri == null)
throw new ArgumentNullException("uri", "The value of the uri parameter cannot be null.");
if (uri.Length == 0)
throw new ArgumentOutOfRangeException("uri", uri, "The value of the uri parameter cannot be empty.");
if (headers == null)
throw new ArgumentNullException("headers", "The value of the headers parameter cannot be null.");
if (body == null)
throw new ArgumentNullException("body", "The value of the body parameter cannot be null.");
if (protocol == null)
throw new ArgumentNullException("protocol", "The value of the protocol parameter cannot be null.");
if (protocol.Length == 0)
throw new ArgumentOutOfRangeException("protocol", protocol, "The value of the protocol parameter cannot be empty.");
this.Body = body;
this.Headers = new Dictionary<string, IEnumerable<string>>(headers, StringComparer.OrdinalIgnoreCase);
this.Method = method;
this.Uri = uri;
this.Protocol = protocol;
this.Query = query.AsQueryDictionary();
this.Session = new NullSessionProvider();
this.ParseFormData();
}
/// <summary>
/// Initializes a new instance of the <see cref="Request"/> class.
/// </summary>
/// <param name="method">The HTTP data transfer method used by the client.</param>
/// <param name="url">The <see cref="Url"/> of the requested resource</param>
/// <param name="headers">The headers that was passed in by the client.</param>
/// <param name="body">The <see cref="Stream"/> that represents the incoming HTTP body.</param>
/// <param name="ip">The client's IP address</param>
/// <param name="certificate">The client's certificate when present.</param>
/// <param name="protocolVersion">The HTTP protocol version.</param>
public Request(string method,
Url url,
RequestStream body = null,
IDictionary<string, IEnumerable<string>> headers = null,
string ip = null,
byte[] certificate = null,
string protocolVersion = null)
{
if (String.IsNullOrEmpty(method))
{
throw new ArgumentOutOfRangeException("method");
}
if (url == null)
{
throw new ArgumentNullException("url");
}
if (url.Path == null)
{
throw new ArgumentNullException("url.Path");
}
if (String.IsNullOrEmpty(url.Scheme))
{
throw new ArgumentOutOfRangeException("url.Scheme");
}
this.UserHostAddress = ip;
this.Url = url;
this.Method = method;
this.Query = url.Query.AsQueryDictionary();
this.Body = body ?? RequestStream.FromStream(new MemoryStream());
this.Headers = new RequestHeaders(headers ?? new Dictionary<string, IEnumerable<string>>());
this.Session = new NullSessionProvider();
if (certificate != null && certificate.Length != 0)
{
this.ClientCertificate = new X509Certificate2(certificate);
}
this.ProtocolVersion = protocolVersion ?? string.Empty;
if (String.IsNullOrEmpty(this.Url.Path))
{
this.Url.Path = "/";
}
this.ParseFormData();
this.RewriteMethod();
}
public void First()
{
stream = new RequestStream(null, firstSeg, firstSeg.Count);
mockObserver.Setup(o => o.OnNext(It.Is<ArraySegment<byte>>(v => v.Equals(firstSeg)))).Verifiable();
mockObserver.Setup(o => o.OnError(It.IsAny<Exception>())).Throws(new Exception("Should not have got error."));
mockObserver.Setup(o => o.OnCompleted()).Verifiable();
stream.ReadAsync().Subscribe(mockObserver.Object);
mockObserver.Verify();
}
public ConnectionInfo(int startBufferOffset, int receiveBufferSize, int constantsOffset, SocketAsyncEventArgs receiveSocketAsyncEventArgs, SocketAsyncEventArgs sendSocketAsyncEventArgs, Socket listenSocket, Func<IDictionary<string, object>, Task> app)
{
StartBufferOffset = startBufferOffset;
ReceiveBufferSize = receiveBufferSize;
ConstantsOffset = constantsOffset;
ReceiveSocketAsyncEventArgs = receiveSocketAsyncEventArgs;
SendSocketAsyncEventArgs = sendSocketAsyncEventArgs;
_buffer = receiveSocketAsyncEventArgs.Buffer;
_listenSocket = listenSocket;
_app = app;
ResponseStream = new ResponseStream(this);
RequestStream = new RequestStream(this);
Environment = new Dictionary<string, object>();
_reqHeaders = new Dictionary<string, string[]>(StringComparer.OrdinalIgnoreCase);
_respHeaders = new Dictionary<string, string[]>(StringComparer.OrdinalIgnoreCase);
}
public void Should_work_even_with_a_non_seekable_stream()
{
var str = A.Fake <Stream>();
A.CallTo(() => str.CanRead).Returns(true);
A.CallTo(() => str.CanSeek).Returns(false);
A.CallTo(() => str.CanTimeout).Returns(true);
A.CallTo(() => str.CanWrite).Returns(true);
// Given
var request = RequestStream.FromStream(str, 0, 1, false);
// When
var result = request.CanRead;
// Then
result.ShouldBeTrue();
}
public void CloseRequestStream()
{
if (RequestStream != null)
{
try
{
RequestStream.Close();
}
// ReSharper disable once EmptyGeneralCatchClause
catch
{
}
finally
{
RequestStream = null;
}
}
}
public void CloseRequestStream()
{
if (RequestStream != null)
{
try
{
RequestStream.Close();
}
catch
{
// ignored
}
finally
{
RequestStream = null;
}
}
}
public void Should_return_result_from_underlaying_beginwrite_when_beginwrite_is_called()
{
// Given
var stream = CreateFakeStream();
var buffer = new byte[10];
var asyncResult = A.Fake <IAsyncResult>();
AsyncCallback callback = x => { };
var state = new object();
var request = RequestStream.FromStream(stream, 0, 10, true);
A.CallTo(() => stream.BeginWrite(buffer, 0, buffer.Length, callback, state)).Returns(asyncResult);
// When
var result = request.BeginWrite(buffer, 0, buffer.Length, callback, state);
// Then
result.ShouldBeSameAs(asyncResult);
}
private Request ConvertRequestToNancyRequest(HttpListenerRequest request)
{
var baseUri = this.baseUriList.FirstOrDefault(uri => uri.IsCaseInsensitiveBaseOf(request.Url));
if (baseUri == null)
{
throw new InvalidOperationException(String.Format("Unable to locate base URI for request: {0}", request.Url));
}
var expectedRequestLength =
GetExpectedRequestLength(request.Headers.ToDictionary());
var relativeUrl = baseUri.MakeAppLocalPath(request.Url);
var nancyUrl = new Url
{
Scheme = request.Url.Scheme,
HostName = request.Url.Host,
Port = request.Url.IsDefaultPort ? null : (int?)request.Url.Port,
BasePath = baseUri.AbsolutePath.TrimEnd('/'),
Path = HttpUtility.UrlDecode(relativeUrl),
Query = request.Url.Query,
};
byte[] certificate = null;
if (this.configuration.EnableClientCertificates)
{
var x509Certificate = request.GetClientCertificate();
if (x509Certificate != null)
{
certificate = x509Certificate.RawData;
}
}
return(new Request(
request.HttpMethod,
nancyUrl,
RequestStream.FromStream(request.InputStream, expectedRequestLength, false),
request.Headers.ToDictionary(),
(request.RemoteEndPoint != null) ? request.RemoteEndPoint.Address.ToString() : null,
certificate));
}
public async Task UploadFiles(IEnumerable <UploadFile> files, NameValueCollection values)
{
string newLine = Environment.NewLine;
string boundary = $"--{this.Boundary}";
long totalBytes = files.Select(f => new FileInfo(f.FileName).Length).Sum();
long sendBytes = 0;
if (values != null)
{
foreach (string name in values.Keys)
{
await WriteString($"{boundary}{newLine}", Encoding.ASCII);
await WriteString($"Content-Disposition: form-data; name=\"{name}\"{newLine}{newLine}", Encoding.ASCII);
await WriteString($"{values[name]}{newLine}", Encoding.UTF8);
}
}
foreach (UploadFile file in files)
{
await WriteString($"{boundary}{newLine}", Encoding.ASCII);
await WriteString($"Content-Disposition: form-data; name=\"{file.Name}\"; filename=\"{Path.GetFileName(file.FileName)}\"{newLine}", Encoding.UTF8);
await WriteString($"Content-Type: {file.ContentType}{newLine}{newLine}", Encoding.ASCII);
using (var fs = File.OpenRead(file.FileName))
{
byte[] buffer = new byte[4096];
int read = 0;
while ((read = await fs.ReadAsync(buffer, 0, buffer.Length)) > 0)
{
await RequestStream.WriteAsync(buffer, 0, read);
sendBytes += read;
this.OnReport(sendBytes / (double)totalBytes);
}
await WriteString(newLine, Encoding.ASCII);
}
}
await WriteString($"{boundary}--", Encoding.ASCII);
}
public Request(string method, Url url, RequestStream body = null, IDictionary <string, IEnumerable <string> > headers = null, string ip = null)
{
if (String.IsNullOrEmpty(method))
{
throw new ArgumentOutOfRangeException("method");
}
if (url == null)
{
throw new ArgumentNullException("url");
}
if (String.IsNullOrEmpty(url.Path))
{
throw new ArgumentOutOfRangeException("url.Path");
}
if (url.Scheme == null)
{
throw new ArgumentNullException("url.Scheme");
}
if (String.IsNullOrEmpty(url.Scheme))
{
throw new ArgumentOutOfRangeException("url.Scheme");
}
this.UserHostAddress = ip;
this.Url = url;
this.Method = method;
this.Query = url.Query.AsQueryDictionary();
this.Body = body ?? RequestStream.FromStream(new MemoryStream());
this.Headers = new RequestHeaders(headers ?? new Dictionary <string, IEnumerable <string> >());
this.Session = new NullSessionProvider();
this.ParseFormData();
this.RewriteMethod();
}
public async Task Invoke(HttpContext environment)
{
var aspnetCoreRequestMethod = environment.Request.Method;
var aspnetCoreRequestScheme = environment.Request.Scheme;
var aspnetCoreRequestHeaders = environment.Request.Headers;
var aspnetCoreRequestPathBase = environment.Request.PathBase;
var aspnetCoreRequestPath = environment.Request.Path;
var aspnetCoreRequestQueryString = environment.Request.QueryString.Value ?? string.Empty;
var aspnetCoreRequestBody = environment.Request.Body;
var aspnetCoreRequestProtocol = environment.Request.Protocol;
var aspnetCoreCallCancelled = environment.RequestAborted;
var aspnetCoreRequestHost = environment.Request.Host.Value ?? Dns.GetHostName();
var aspnetCoreUser = environment.User;
X509Certificate2 certificate = null;
if (_options.EnableClientCertificates)
{
var clientCertificate = new X509Certificate2(environment.Connection.ClientCertificate.Export(X509ContentType.Cert));
certificate = clientCertificate ?? null;
}
var serverClientIp = environment.Connection.RemoteIpAddress.ToString();
var url = CreateUrl(aspnetCoreRequestHost, aspnetCoreRequestScheme, aspnetCoreRequestPathBase, aspnetCoreRequestPath, aspnetCoreRequestQueryString);
var nancyRequestStream = new RequestStream(aspnetCoreRequestBody, ExpectedLength(aspnetCoreRequestHeaders), StaticConfiguration.DisableRequestStreamSwitching ?? false);
var nancyRequest = new Request(
aspnetCoreRequestMethod,
url,
nancyRequestStream,
aspnetCoreRequestHeaders.ToDictionary(kv => kv.Key, kv => (IEnumerable <string>)kv.Value, StringComparer.OrdinalIgnoreCase),
serverClientIp,
certificate,
aspnetCoreRequestProtocol);
var nancyContext = await _engine.HandleRequest(
nancyRequest,
StoreEnvironment(environment, aspnetCoreUser),
aspnetCoreCallCancelled).ConfigureAwait(false);
await RequestComplete(nancyContext, environment, _options.PerformPassThrough, _next).ConfigureAwait(false);
}
public Request(string method, Url url, RequestStream body = null, IDictionary<string, IEnumerable<string>> headers = null, string ip = null)
{
if (String.IsNullOrEmpty(method))
{
throw new ArgumentOutOfRangeException("method");
}
if (url == null)
{
throw new ArgumentNullException("url");
}
if (String.IsNullOrEmpty(url.Path))
{
throw new ArgumentOutOfRangeException("url.Path");
}
if (url.Scheme == null)
{
throw new ArgumentNullException("url.Scheme");
}
if (String.IsNullOrEmpty(url.Scheme))
{
throw new ArgumentOutOfRangeException("url.Scheme");
}
this.UserHostAddress = ip;
this.Url = url;
this.Method = method;
this.Query = url.Query.AsQueryDictionary();
this.Body = body ?? RequestStream.FromStream(new MemoryStream());
this.Headers = new RequestHeaders(headers ?? new Dictionary<string, IEnumerable<string>>());
this.Session = new NullSessionProvider();
this.ParseFormData();
this.RewriteMethod();
}
/// <summary>
/// Read the http stream as a <see cref="Request"/>.
/// </summary>
/// <param name="stream">The http stream.</param>
/// <param name="scheme">The url scheme.</param>
/// <param name="ip">The ip address.</param>
/// <returns>Returns the parse <see cref="Request"/>.</returns>
public static Request ReadAsRequest(this Stream stream, IDictionary <string, IEnumerable <string> > headers)
{
if (stream == null)
{
throw new ArgumentNullException("stream");
}
var requestLine = RequestLineParser.Parse(stream);
var url = new Url();
if (requestLine.Uri.StartsWith("http", StringComparison.InvariantCultureIgnoreCase))
{
Uri uri;
if (Uri.TryCreate(requestLine.Uri, UriKind.Absolute, out uri))
{
url.Path = uri.AbsolutePath;
url.Query = uri.Query;
//url.Fragment = uri.Fragment;
url.Scheme = uri.Scheme;
}
}
else
{
var splitUri = requestLine.Uri.Split('?');
url.Path = splitUri[0];
url.Query = splitUri.Length == 2 ? splitUri[1] : string.Empty;
url.Scheme = "https";
}
IEnumerable <string> headerValues;
if (headers.TryGetValue("Host", out headerValues))
{
url.HostName = headerValues.FirstOrDefault();
}
var nestedRequestStream = new RequestStream(new HttpMultipartSubStream(stream, stream.Position, stream.Length), stream.Length - stream.Position, true);
var request = new Request(requestLine.Method, url, nestedRequestStream, headers, null);
return(request);
}
/// <summary>
/// OWIN App Action
/// </summary>
/// <param name="environment">Application environment</param>
/// <returns>Returns result</returns>
public Task Invoke(IDictionary <string, object> environment)
{
var owinRequestMethod = Get <string>(environment, "owin.RequestMethod");
var owinRequestScheme = Get <string>(environment, "owin.RequestScheme");
var owinRequestHeaders = Get <IDictionary <string, string[]> >(environment, "owin.RequestHeaders");
var owinRequestPathBase = Get <string>(environment, "owin.RequestPathBase");
var owinRequestPath = Get <string>(environment, "owin.RequestPath");
var owinRequestQueryString = Get <string>(environment, "owin.RequestQueryString");
var owinRequestBody = Get <Stream>(environment, "owin.RequestBody");
var owinCallCancelled = Get <CancellationToken>(environment, "owin.CallCancelled");
var owinRequestHost = GetHeader(owinRequestHeaders, "Host") ?? Dns.GetHostName();
byte[] certificate = null;
if (this.options.EnableClientCertificates)
{
var clientCertificate = Get <X509Certificate>(environment, "ssl.ClientCertificate");
certificate = (clientCertificate == null) ? null : clientCertificate.GetRawCertData();
}
var serverClientIp = Get <string>(environment, "server.RemoteIpAddress");
var url = CreateUrl(owinRequestHost, owinRequestScheme, owinRequestPathBase, owinRequestPath, owinRequestQueryString);
var nancyRequestStream = new RequestStream(owinRequestBody, ExpectedLength(owinRequestHeaders), false);
var nancyRequest = new Request(
owinRequestMethod,
url,
nancyRequestStream,
owinRequestHeaders.ToDictionary(kv => kv.Key, kv => (IEnumerable <string>)kv.Value, StringComparer.OrdinalIgnoreCase),
serverClientIp,
certificate);
var tcs = new TaskCompletionSource <int>();
this.engine.HandleRequest(
nancyRequest,
StoreEnvironment(environment),
RequestComplete(environment, this.options.PerformPassThrough, this.next, tcs),
RequestErrored(tcs),
owinCallCancelled);
return(tcs.Task);
}
public AnalyticsModule()
{
Get("/_analytics", parameters =>
{
return(new FhirReader().ReadPatient(parameters.id));
//return $"I am a Patient: {parameters.id}";
});
Post("/_analytics", parameters =>
{
var body = RequestStream.FromStream(Request.Body).AsString();
var result = new FhirReader().RunAnalytics(body);
return(Response.AsText(result, "application/json"));
//return $"I am a Patient: {parameters.id}";
});
}
private static Request CreateNancyRequestFromIncomingWebRequest(IncomingWebRequestContext webRequest, Stream requestBody)
{
var address =
((RemoteEndpointMessageProperty)
OperationContext.Current.IncomingMessageProperties[RemoteEndpointMessageProperty.Name]);
var relativeUri = GetUrlAndPathComponents(webRequest.UriTemplateMatch.BaseUri).MakeRelativeUri(GetUrlAndPathComponents(webRequest.UriTemplateMatch.RequestUri));
var expectedRequestLength =
GetExpectedRequestLength(webRequest.Headers.ToDictionary());
return(new Request(
webRequest.Method,
string.Concat("/", relativeUri),
webRequest.Headers.ToDictionary(),
RequestStream.FromStream(requestBody, expectedRequestLength, false),
webRequest.UriTemplateMatch.RequestUri.Scheme,
webRequest.UriTemplateMatch.RequestUri.Query,
address.Address));
}
private static Request CreateRequest(string method, Url url, IBrowserContextValues contextValues)
{
BuildRequestBody(contextValues);
var requestStream =
RequestStream.FromStream(contextValues.Body, 0, true);
var certBytes = (contextValues.ClientCertificate == null)
? ArrayCache.Empty <byte>()
: contextValues.ClientCertificate.GetRawCertData();
var requestUrl = url;
requestUrl.Scheme = string.IsNullOrWhiteSpace(contextValues.Protocol) ? requestUrl.Scheme : contextValues.Protocol;
requestUrl.HostName = string.IsNullOrWhiteSpace(contextValues.HostName) ? requestUrl.HostName : contextValues.HostName;
requestUrl.Query = string.IsNullOrWhiteSpace(url.Query) ? (contextValues.QueryString ?? string.Empty) : url.Query;
return(new Request(method, requestUrl, requestStream, contextValues.Headers, contextValues.UserHostAddress, certBytes));
}
private Request CreateRequest(string method, string path, Action <BrowserContext> browserContext)
{
var context =
new BrowserContext();
this.SetCookies(context);
browserContext.Invoke(context);
var contextValues =
(IBrowserContextValues)context;
BuildRequestBody(contextValues);
var requestStream =
RequestStream.FromStream(contextValues.Body, 0, true);
return(new Request(method, path, contextValues.Headers, requestStream, contextValues.Protocol, contextValues.QueryString));
}
public RequestStream GetRequestStream(bool chunked, long contentlength)
{
if (i_stream == null)
{
byte[] buffer = ms.GetBuffer();
int length = (int)ms.Length;
ms = null;
if (chunked)
{
this.chunked = true;
context.Response.SendChunked = true;
i_stream = new ChunkedInputStream(context, stream, buffer, position, length - position);
}
else
{
i_stream = new RequestStream(stream, buffer, position, length - position, contentlength);
}
}
return(i_stream);
}
private static Request CreateNancyRequest(HttpContextBase context)
{
var incomingHeaders = context.Request.Headers.ToDictionary();
var expectedRequestLength =
GetExpectedRequestLength(incomingHeaders);
var basePath = context.Request.ApplicationPath.TrimEnd('/');
var path = context.Request.Url.AbsolutePath.Substring(basePath.Length);
path = string.IsNullOrWhiteSpace(path) ? "/" : path;
var nancyUrl = new Url
{
Scheme = context.Request.Url.Scheme,
HostName = context.Request.Url.Host,
Port = context.Request.Url.Port,
BasePath = basePath,
Path = path,
Query = context.Request.Url.Query,
Fragment = context.Request.Url.Fragment,
};
byte[] certificate = null;
if (context.Request.ClientCertificate != null &&
context.Request.ClientCertificate.IsPresent &&
context.Request.ClientCertificate.Certificate.Length != 0)
{
certificate = context.Request.ClientCertificate.Certificate;
}
return(new Request(
context.Request.HttpMethod.ToUpperInvariant(),
nancyUrl,
RequestStream.FromStream(context.Request.InputStream, expectedRequestLength, true),
incomingHeaders,
context.Request.UserHostAddress,
certificate));
}
/// <summary>
/// OWIN App Action
/// </summary>
/// <param name="environment">Application environment</param>
/// <returns>Returns result</returns>
public Task Invoke(IDictionary <string, object> environment)
{
var owinRequestMethod = Get <string>(environment, "owin.RequestMethod");
var owinRequestScheme = Get <string>(environment, "owin.RequestScheme");
var owinRequestHeaders = Get <IDictionary <string, string[]> >(environment, "owin.RequestHeaders");
var owinRequestPathBase = Get <string>(environment, "owin.RequestPathBase");
var owinRequestPath = Get <string>(environment, "owin.RequestPath");
var owinRequestQueryString = Get <string>(environment, "owin.RequestQueryString");
var owinRequestBody = Get <Stream>(environment, "owin.RequestBody");
var serverClientIp = Get <string>(environment, "server.RemoteIpAddress");
//var callCancelled = Get<CancellationToken>(environment, "owin.RequestBody");
var url = new Url
{
Scheme = owinRequestScheme,
HostName = GetHeader(owinRequestHeaders, "Host"),
Port = null,
BasePath = owinRequestPathBase,
Path = owinRequestPath,
Query = owinRequestQueryString,
};
var nancyRequestStream = new RequestStream(owinRequestBody, ExpectedLength(owinRequestHeaders), false);
var nancyRequest = new Request(
owinRequestMethod,
url,
nancyRequestStream,
owinRequestHeaders.ToDictionary(kv => kv.Key, kv => (IEnumerable <string>)kv.Value, StringComparer.OrdinalIgnoreCase),
serverClientIp);
var tcs = new TaskCompletionSource <int>();
this.engine.HandleRequest(
nancyRequest,
StoreEnvironment(environment),
RequestComplete(environment, tcs),
RequestErrored(tcs));
return(tcs.Task);
}
public static JObject BodyToJObject(RequestStream body)
{
body.Position = 0;
JObject jsonObject = null;
using (var memory = new MemoryStream())
{
try
{
body.CopyTo(memory);
var str = Encoding.UTF8.GetString(memory.ToArray());
if (!string.IsNullOrEmpty(str))
{
jsonObject = JObject.Parse(str);
}
}
catch { }
}
return(jsonObject);
}
public void FirstAndOne()
{
var restSeg = new ArraySegment<byte>(buffer, first.Length, last.Length);
stream = new RequestStream(mockSocket.Object, firstSeg, buffer.Length);
mockObserver.Setup(o => o.OnNext(It.Is<ArraySegment<byte>>(v => v.Equals(firstSeg)))).Verifiable();
mockObserver.Setup(o => o.OnError(It.IsAny<Exception>())).Throws(new Exception("Should not have got error."));
mockObserver.Setup(o => o.OnCompleted()).Verifiable();
stream.ReadAsync().Subscribe(mockObserver.Object);
mockObserver.Verify();
int bufferSize = 1024;
mockSocket
.Setup(s => s.Read(
It.Is<byte[]>(b => b.Length == bufferSize),
It.Is<int>(o => o == 0),
It.Is<int>(c => c == bufferSize)))
.Returns<byte[], int, int>((byte[] b, int o, int c) =>
Observable.Create<int>(ob =>
{
ob.OnNext(restSeg.Count);
ob.OnCompleted();
return () => { };
}))
.Verifiable();
mockObserver.Setup(o => o.OnNext(It.Is<ArraySegment<byte>>(v => v.Count == restSeg.Count))).Verifiable();
mockObserver.Setup(o => o.OnError(It.IsAny<Exception>())).Throws(new Exception("Should not have got error."));
mockObserver.Setup(o => o.OnCompleted()).Verifiable();
stream.ReadAsync().Subscribe(mockObserver.Object);
mockSocket.Verify();
mockObserver.Verify();
}
public object Proxy()
{
var baseUrl = this.GetBaseUrl();
var method = this.Context.Request.Method;
var queryAsString = this.Context.Request.Url.Query;
var query = this.GetQueryString(queryAsString);
var path = this.Context.Request.Url.Path;
var headers = this.GetRequestHeaders();
var headersAsString = this.GetRequestHeadersAsString(headers);
var body = "";
if (method.ToLowerInvariant() != "get")
{
body = RequestStream.FromStream(this.Context.Request.Body).AsString();
}
this.PrintRequest(baseUrl, method, path, queryAsString, body, headersAsString);
var restResponse = this.ExecuteRequestToTunnel(baseUrl, method, path, body, query, headers);
return(this.GetProxyResponse(restResponse));
}
public ProductController()
{
Get("/", _ => "Hello Nancy");
Get("/products/name/{name}", parameters => {
return("Hello " + parameters.name);
});
Get("/products", _ => {
return(Products);
});
Post("/products", product =>
{
var text = RequestStream.FromStream(Request.Body).AsString();
var newProduct = JsonConvert.DeserializeObject <Product>(text);
Products.Add(newProduct);
return("Exito");
});
}
private NancyContext PopulateForm(string cultureName)
{
string bodyContent = string.Concat("CurrentCulture=", cultureName);
var memory = new MemoryStream();
var writer = new StreamWriter(memory);
writer.Write(bodyContent);
writer.Flush();
memory.Position = 0;
var headers =
new Dictionary <string, IEnumerable <string> >
{
{ "content-type", new[] { "application/x-www-form-urlencoded" } }
};
var context = new NancyContext();
context.Request = new Request("POST", "/", headers, RequestStream.FromStream(memory), "http");
return(context);
}
internal void Complete(int read, uint errorCode = UnsafeNclNativeMethods.ErrorCodes.ERROR_SUCCESS)
{
if (_requestStream.TryCheckSizeLimit(read + (int)DataAlreadyRead, out var exception))
{
_tcs.TrySetException(exception);
}
else if (_tcs.TrySetResult(read + (int)DataAlreadyRead))
{
RequestStream.UpdateAfterRead((uint)errorCode, (uint)(read + DataAlreadyRead));
if (_callback != null)
{
try
{
_callback(this);
}
catch (Exception)
{
// TODO: Exception handling? This may be an IO callback thread and throwing here could crash the app.
}
}
}
Dispose();
}
private static Request CreateNancyRequest(HttpContextBase context)
{
var expectedRequestLength =
GetExpectedRequestLength(context.Request.Headers.ToDictionary());
var nancyUrl = new Url
{
Scheme = context.Request.Url.Scheme,
HostName = context.Request.Url.Host,
Port = context.Request.Url.Port,
BasePath = context.Request.ApplicationPath.TrimEnd('/'),
Path = context.Request.AppRelativeCurrentExecutionFilePath.Replace("~", string.Empty),
Query = context.Request.Url.Query,
Fragment = context.Request.Url.Fragment,
};
return(new Request(
context.Request.HttpMethod.ToUpperInvariant(),
nancyUrl,
RequestStream.FromStream(context.Request.InputStream, expectedRequestLength, true),
context.Request.Headers.ToDictionary(),
context.Request.UserHostAddress));
}
public void AsString_should_always_start_from_position_0_and_reset_it_afterwards()
{
// Given
using (var innerStream = new MemoryStream())
using (var streamWriter = new StreamWriter(innerStream, Encoding.UTF8)
{
AutoFlush = true
})
{
streamWriter.Write("fake request body");
var requestStream = RequestStream.FromStream(innerStream);
var initialPosition = requestStream.Position = 3;
// When
var result = requestStream.AsString(Encoding.UTF8);
// Then
Assert.Equal("fake request body", result);
Assert.Equal(initialPosition, requestStream.Position);
}
}
public void Handle_WithAPostRequestToPactAndNoInteractionsHaveBeenRegistered_NewPactFileIsSavedWithNoInteractions()
{
var pactDetails = new PactDetails
{
Consumer = new Party {
Name = "Consumer"
},
Provider = new Party {
Name = "Provider"
}
};
var pactFile = new ProviderServicePactFile
{
Provider = pactDetails.Provider,
Consumer = pactDetails.Consumer,
Interactions = new ProviderServiceInteraction[0]
};
var pactFileJson = JsonConvert.SerializeObject(pactFile, JsonConfig.PactFileSerializerSettings);
var pactDetailsJson = JsonConvert.SerializeObject(pactDetails, JsonConfig.ApiSerializerSettings);
var jsonStream = new MemoryStream(Encoding.UTF8.GetBytes(pactDetailsJson));
var requestStream = new RequestStream(jsonStream, jsonStream.Length, true);
var context = new NancyContext
{
Request = new Request("POST", new Url("http://localhost/pact"), requestStream)
};
var handler = GetSubject();
handler.Handle(context);
_mockFileSystem.File.Received(1).WriteAllText(Path.Combine(Constants.DefaultPactFileDirectory, pactDetails.GeneratePactFileName()), pactFileJson);
}
private async Task<Request> MapNancyRequest(HttpRequestMessage request)
{
IEnumerable<KeyValuePair<string, IEnumerable<string>>> headersToCopy = request.Headers;
RequestStream requestStream = null;
if (request.Content != null)
{
headersToCopy = headersToCopy.Concat(request.Content.Headers);
requestStream = new RequestStream(await request.Content.ReadAsStreamAsync(),
request.Content.Headers.ContentLength.GetValueOrDefault(), true);
}
if (Credentials != null)
{
string encodedCredentials =
Convert.ToBase64String(Encoding.UTF8.GetBytes($"{Credentials.UserName}:{Credentials.Password}"));
headersToCopy =
headersToCopy.Append(new KeyValuePair<string, IEnumerable<string>>("Authorization",
new[] { "Basic " + encodedCredentials }));
}
var nancyRequest = new Request(request.Method.ToString(), request.RequestUri,
requestStream, headersToCopy.ToDictionary(x => x.Key, x => x.Value));
return nancyRequest;
}
private Request ConvertRequest(Uri baseUri, HttpListenerRequest httpRequest)
{
var expectedRequestLength = GetExpectedRequestLength(ConvertToDictionary(httpRequest.Headers));
var url = new Url
{
Scheme = httpRequest.Url.Scheme,
HostName = httpRequest.Url.Host,
Port = httpRequest.Url.IsDefaultPort ? null : (int?)httpRequest.Url.Port,
BasePath = baseUri.AbsolutePath.TrimEnd('/'),
Path = baseUri.MakeAppLocalPath(httpRequest.Url),
Query = httpRequest.Url.Query,
};
var fieldCount = httpRequest.ProtocolVersion.Major == 2 ? 1 : 2;
var protocolVersion = string.Format("HTTP/{0}", httpRequest.ProtocolVersion.ToString(fieldCount));
byte[] certificate = null;
if (httpRequest.IsSecureConnection)
{
var x509Certificate = httpRequest.GetClientCertificate();
if (x509Certificate != null)
{
certificate = x509Certificate.RawData;
}
}
return(new Request(
httpRequest.HttpMethod,
url,
RequestStream.FromStream(httpRequest.InputStream, expectedRequestLength, false),
ConvertToDictionary(httpRequest.Headers),
httpRequest.RemoteEndPoint,
protocolVersion,
certificate));
}
void Init()
{
if (ssl_stream != null)
{
//ssl_stream.AuthenticateAsServer(client_cert, true, (SslProtocols)ServicePointManager.SecurityProtocol, false);
}
context_bound = false;
i_stream = null;
o_stream = null;
prefix = null;
chunked = false;
ms = new MemoryStream();
position = 0;
input_state = InputState.RequestLine;
line_state = LineState.None;
context = new HttpListenerContext(this, _logger);
}
void Init()
{
context_bound = false;
i_stream = null;
o_stream = null;
prefix = null;
chunked = false;
ms = new MemoryStream();
position = 0;
input_state = InputState.RequestLine;
line_state = LineState.None;
context = new HttpListenerContext(this);
}
public override Stream GetRequestStream()
{
if (_requestStream == null)
_requestStream = new RequestStream(this);
return _requestStream;
}
private void Init()
{
#if SSL
if (ssl_stream != null)
{
ssl_stream.AuthenticateAsServer(cert, true, (SslProtocols)ServicePointManager.SecurityProtocol, false);
}
#endif
_contextBound = false;
_iStream = null;
_oStream = null;
Prefix = null;
_chunked = false;
_ms = new MemoryStream();
_position = 0;
_inputState = InputState.RequestLine;
_lineState = LineState.None;
_context = new HttpListenerContext(this);
}
/// <summary>
/// Initializes a new instance of the <see cref="Request"/> class.
/// </summary>
/// <param name="method">The HTTP data transfer method used by the client.</param>
/// <param name="path">The path of the requested resource, relative to the "Nancy root". This shold not not include the scheme, host name, or query portion of the URI.</param>
/// <param name="headers">The headers that was passed in by the client.</param>
/// <param name="body">The <see cref="Stream"/> that represents the incoming HTTP body.</param>
/// <param name="scheme">The HTTP scheme that was used by the client.</param>
/// <param name="query">The querystring data that was sent by the client.</param>
public Request(string method, string path, IDictionary<string, IEnumerable<string>> headers, RequestStream body, string scheme, string query = null, string ip = null)
: this(method, new Url { Path=path, Scheme = scheme, Query = query ?? String.Empty}, body, headers, ip)
{
}
public RequestStream GetRequestStream(bool chunked, long contentlength)
{
if (_iStream != null) return _iStream;
var buffer = _ms.ToArray();
var length = (int) _ms.Length;
_ms = null;
if (chunked)
{
_chunked = true;
_context.Response.SendChunked = true;
_iStream = new ChunkedInputStream(_context, _stream, buffer, _position, length - _position);
}
else
{
_iStream = new RequestStream(_stream, buffer, _position, length - _position, contentlength);
}
return _iStream;
}
private void disposeStream ()
{
if (_stream == null)
return;
_inputStream = null;
_outputStream = null;
_stream.Dispose ();
_stream = null;
}
public RequestStream GetRequestStream (long contentLength, bool chunked)
{
if (_inputStream != null || _socket == null)
return _inputStream;
lock (_sync) {
if (_socket == null)
return _inputStream;
var buff = _requestBuffer.GetBuffer ();
var len = (int) _requestBuffer.Length;
disposeRequestBuffer ();
if (chunked) {
_context.Response.SendChunked = true;
_inputStream = new ChunkedRequestStream (
_stream, buff, _position, len - _position, _context);
}
else {
_inputStream = new RequestStream (
_stream, buff, _position, len - _position, contentLength);
}
return _inputStream;
}
}
private void Init()
{
_chunked = false;
_context = new HttpListenerContext (this);
_contextWasBound = false;
_inputState = InputState.RequestLine;
_inputStream = null;
_lineState = LineState.None;
_outputStream = null;
_position = 0;
_prefix = null;
_requestBuffer = new MemoryStream ();
_timeout = 90000; // 90k ms for first request, 15k ms from then on.
}
public RequestStream GetRequestStream(bool chunked, long contentlength)
{
if (_inputStream == null) {
var buffer = _requestBuffer.GetBuffer ();
var length = buffer.Length;
_requestBuffer = null;
if (chunked) {
_chunked = true;
_context.Response.SendChunked = true;
_inputStream = new ChunkedInputStream (_context, _stream, buffer, _position, length - _position);
} else {
_inputStream = new RequestStream (_stream, buffer, _position, length - _position, contentlength);
}
}
return _inputStream;
}
public FakeRequest(string method, string path, string query, string userHostAddress = null)
: this(method, path, new Dictionary <string, IEnumerable <string> >(), RequestStream.FromStream(new MemoryStream()), "http", query, userHostAddress)
{
}
public static byte[] HandleRequest(string method, string uri, string query, Dictionary<string, string> headers, IPAddress ip)
{
var nuri = new Url
{
Scheme = "http",
HostName = GetHeader(headers, "Host"),
Port = null,
BasePath = "",
Path = uri,
Query = query
};
var contentLength = ExpectedLength(headers);
var bodyStream = Stream.Null;
if (contentLength > 0)
{
var bodyBytes = GameInterface.ReadHTTPBody((int)contentLength);
bodyStream = new MemoryStream(bodyBytes);
}
var body = new RequestStream(bodyStream, contentLength, false);
var headerDictionary = headers.ToDictionary(kv => kv.Key, kv => (IEnumerable<string>)new[] { kv.Value }, StringComparer.OrdinalIgnoreCase);
var request = new Request(method, nuri, body, headerDictionary, ip.ToString());
var context = _engine.HandleRequest(request);
var responseStatusCode = context.Response.StatusCode;
var responseStream = new MemoryStream();
context.Response.Contents(responseStream);
responseStream.Position = 0;
var response = new StringBuilder();
response.Append("HTTP/1.0 ");
response.Append(((int)responseStatusCode).ToString());
response.Append(" ");
response.Append(_statusCodes[(int)responseStatusCode]);
response.Append("\r\n");
foreach (var header in context.Response.Headers)
{
response.Append(header.Key);
response.Append(": ");
response.Append(string.Join(", ", header.Value));
response.Append("\r\n");
}
if (context.Response.ContentType != null)
{
response.Append("Content-Type: ");
response.Append(context.Response.ContentType);
response.Append("\r\n");
}
if (context.Response.Cookies != null && context.Response.Cookies.Count != 0)
{
var cookies = context.Response.Cookies.Select(cookie => cookie.ToString()).ToArray();
response.Append("Set-Cookie: ");
response.Append(string.Join(", ", cookies));
response.Append("\r\n");
}
response.Append("\r\n");
var headerBytes = Encoding.UTF8.GetBytes(response.ToString());
var dataBytes = new byte[responseStream.Length + headerBytes.Length];
Array.Copy(headerBytes, dataBytes, headerBytes.Length);
responseStream.Read(dataBytes, headerBytes.Length, (int)responseStream.Length);
//Log.Debug(context.Trace.TraceLog.ToString());
context.Dispose();
return dataBytes;
}
private void init ()
{
_context = new HttpListenerContext (this);
_inputState = InputState.RequestLine;
_inputStream = null;
_lineState = LineState.None;
_outputStream = null;
_position = 0;
_prefix = null;
_requestBuffer = new MemoryStream ();
}
public RequestStream GetRequestStream(bool chunked, long contentlength)
{
if (i_stream == null) {
byte [] buffer = ms.GetBuffer ();
int length = (int) ms.Length;
ms = null;
if (chunked) {
this.chunked = true;
context.Response.SendChunked = true;
i_stream = new ChunkedInputStream (context, stream, buffer, position, length - position);
} else {
i_stream = new RequestStream (stream, buffer, position, length - position, contentlength);
}
}
return i_stream;
}
public Task Invoke(IDictionary <string, object> env)
{
var owinRequestMethod = Get <string>(env, OwinConstants.RequestMethod);
var owinRequestScheme = Get <string>(env, OwinConstants.RequestScheme);
var owinRequestHeaders = Get <IDictionary <string, string[]> >(env, OwinConstants.RequestHeaders);
var owinRequestPathBase = Get <string>(env, OwinConstants.RequestPathBase);
var owinRequestPath = Get <string>(env, OwinConstants.RequestPath);
var owinRequestQueryString = Get <string>(env, OwinConstants.RequestQueryString);
var owinRequestBody = Get <Stream>(env, OwinConstants.RequestBody);
var serverClientIp = Get <string>(env, OwinConstants.RemoteIpAddress);
var owinResponseHeaders = Get <IDictionary <string, string[]> >(env, OwinConstants.ResponseHeaders);
var owinResponseBody = Get <Stream>(env, OwinConstants.ResponseBody);
var url = new Url
{
Scheme = owinRequestScheme,
HostName = GetHeader(owinRequestHeaders, "Host"),
Port = null,
BasePath = owinRequestPathBase,
Path = owinRequestPath,
Query = owinRequestQueryString,
};
var body = new RequestStream(owinRequestBody, ExpectedLength(owinRequestHeaders), false);
var nancyRequest = new Request(
owinRequestMethod,
url,
body,
owinRequestHeaders.ToDictionary(kv => kv.Key, kv => (IEnumerable <string>)kv.Value, StringComparer.OrdinalIgnoreCase),
serverClientIp);
var tcs = new TaskCompletionSource <object>();
_engine.HandleRequest(
nancyRequest,
context =>
{
var nancyResponse = context.Response;
if (_next != null && nancyResponse.StatusCode == HttpStatusCode.NotFound)
{
_next(env).CopyResultToCompletionSource(tcs, null);
}
else
{
env[OwinConstants.ResponseStatusCode] = (int)nancyResponse.StatusCode;
foreach (var header in nancyResponse.Headers)
{
owinResponseHeaders.Add(header.Key, new string[] { header.Value });
}
if (!string.IsNullOrWhiteSpace(nancyResponse.ContentType))
{
owinResponseHeaders["Content-Type"] = new[] { nancyResponse.ContentType };
}
if (nancyResponse.Cookies != null && nancyResponse.Cookies.Count != 0)
{
owinResponseHeaders["Set-Cookie"] = nancyResponse.Cookies.Select(cookie => cookie.ToString()).ToArray();
}
nancyResponse.Contents(owinResponseBody);
context.Dispose();
tcs.TrySetResult(null);
}
},
tcs.SetException);
return(tcs.Task);
}
void Init()
{
context_bound = false;
i_stream = null;
o_stream = null;
prefix = null;
chunked = false;
ms = new MemoryStream ();
position = 0;
input_state = InputState.RequestLine;
line_state = LineState.None;
context = new HttpListenerContext (this);
s_timeout = 90000; // 90k ms for first request, 15k ms from then on
}
public FakeRequest(string method, string path, IDictionary <string, IEnumerable <string> > headers)
: this(method, path, headers, RequestStream.FromStream(new MemoryStream()), "http", string.Empty)
{
}
public FakeRequest(string method, string path, IDictionary<string, IEnumerable<string>> headers, RequestStream body, string protocol, string query)
: base(method, path, headers, body, protocol, query)
{
}
public FakeRequest(string method, string path, IDictionary <string, IEnumerable <string> > headers, RequestStream body, string protocol, string query, string userHostAddress = null)
: base(method, new Url {
Path = path, Query = query, Scheme = protocol
}, body, headers, ip: userHostAddress)
{
}
public FakeRequest(string method, string path, IDictionary<string, IEnumerable<string>> headers, RequestStream body, string protocol, string query)
: base(method, new Url { Path = path, Query = query, Scheme = protocol }, body, headers)
{
}
