public ServerRequest(IDictionary<string, object> environment)
{
_request = new OwinRequest(environment);
// Cache user because AspNetWebSocket.CloseOutputAsync clears it. We need it during Hub.OnDisconnected
_user = _request.User;
}
public Task Invoke(IDictionary<string, object> env)
{
var request = new OwinRequest(env);
var response = new OwinResponse(env);
if (!request.Uri.Scheme.Equals("https", StringComparison.OrdinalIgnoreCase))
{
var builder = new UriBuilder(request.Uri);
builder.Scheme = "https";
if (request.Uri.IsDefaultPort)
{
builder.Port = -1;
}
response.Headers.Set("Location", builder.ToString());
response.StatusCode = 302;
return TaskAsyncHelper.Empty;
}
else
{
return _next(env);
}
}
public async static Task AppFunction(IDictionary<string, object> environment)
{
// process response
var owinResponse = new OwinResponse(environment);
var owinRequest = new OwinRequest(environment);
var writer = new StreamWriter(owinResponse.Body);
switch (owinRequest.Path)
{
case "/10mbTest.txt":
writer.Write(TestHelpers.FileContent10MbTest);
break;
case "/simpleTest.txt":
writer.Write(TestHelpers.FileContentSimpleTest);
break;
case "/emptyFile.txt":
writer.Write(TestHelpers.FileContentEmptyFile);
break;
default:
writer.Write(TestHelpers.FileContentAnyFile);
break;
}
await writer.FlushAsync();
owinResponse.ContentLength = owinResponse.Body.Length;
owinResponse.ContentType = "text/plain";
}
public Task Invoke(IDictionary<string, object> env)
{
try
{
var request = new OwinRequest(env);
var path = request.Path.ToString();
logger.Info("Execute action: {0};", path);
IListenerHandler handler;
if (handlers.TryGetValue(path, out handler))
return handler.ProcessRequest(request);
else
logger.Info(string.Format("Handler for url '{0}' is not found", path));
}
catch (Exception ex)
{
logger.Error(ex, "");
var tcs = new TaskCompletionSource<object>();
tcs.SetException(ex);
return tcs.Task;
}
return next(env);
}
public override async Task Invoke(IOwinContext context)
{
// process response
var owinResponse = new OwinResponse(context.Environment) { ContentType = "text/plain" };
var owinRequest = new OwinRequest(context.Environment);
var writer = new StreamWriter(owinResponse.Body);
switch (owinRequest.Path.Value)
{
case "/root/10mbTest.txt":
writer.Write(TestHelpers.FileContent5bTest);
owinResponse.ContentLength = TestHelpers.FileContent5bTest.Length;
break;
case "/root/simpleTest.txt":
writer.Write(TestHelpers.FileContentSimpleTest);
owinResponse.ContentLength = TestHelpers.FileContentSimpleTest.Length;
break;
case "/root/index.html":
writer.Write(TestHelpers.FileContentIndex);
owinResponse.ContentLength = TestHelpers.FileContentIndex.Length;
break;
case "/root/emptyFile.txt":
writer.Write(TestHelpers.FileContentEmptyFile);
owinResponse.ContentLength = TestHelpers.FileContentEmptyFile.Length;
break;
default:
writer.Write(TestHelpers.FileContentAnyFile);
owinResponse.ContentLength = TestHelpers.FileContentAnyFile.Length;
break;
}
await writer.FlushAsync();
}
private static HttpRequestParams GetRequestParams(OwinRequest request)
{
var task = request.ReadFormAsync();
task.Wait();
return new HttpRequestParams(request.Query, task.Result);
}
public override Task ProcessRequest(HostContext context)
{
string alterWhen = "____Never____";
int statusCode = 200;
if (!String.IsNullOrEmpty(context.Request.QueryString["alterWhen"]))
{
alterWhen = context.Request.QueryString["alterWhen"];
}
if (!String.IsNullOrEmpty(context.Request.QueryString["statusCode"]))
{
statusCode = Int32.Parse(context.Request.QueryString["statusCode"]);
}
var owinRequest = new OwinRequest(context.Environment);
if (owinRequest.Path.Value.Contains("/" + alterWhen))
{
var response = new OwinResponse(context.Environment);
// Alter status code
response.StatusCode = statusCode;
using (var sw = new StreamWriter(response.Body))
{
sw.WriteLine("Hello world");
sw.Flush();
}
return TaskAsyncHelper.Empty;
}
return base.ProcessRequest(context);
}
/// <summary>
/// Inspects the environment and checks to see if this is a POST containing the HTML form fields in the login.html page.
/// </summary>
/// <param name="environment"></param>
/// <param name="formsAuthenticationProvider"></param>
public LoginContext(IDictionary<string, object> environment, FormsAuthenticationProvider formsAuthenticationProvider)
{
_environment = environment;
Request = new OwinRequest(environment);
Response = new OwinResponse(environment);
_formsAuthenticationProvider = formsAuthenticationProvider;
_responseStream = Response.Body;
var requestContentType = Request.GetHeader("Content-Type");
_isFormUrlEncodedPost = Request.Method == "POST" && !string.IsNullOrEmpty(requestContentType) && requestContentType.StartsWith("application/x-www-form-urlencoded");
if (_isFormUrlEncodedPost && Request.Body != null)
{
_formData = Request.ReadForm().Result;
var username = _formData["login_username"];
var password = _formData["login_password"];
var rememberMe = _formData["remember_me"] != null && _formData["remember_me"] == "yes";
if (!string.IsNullOrEmpty(username) && !string.IsNullOrEmpty(password))
{
environment["formsauthn.username"] = username;
environment["formsauthn.password"] = password;
environment["formsauthn.remember"] = rememberMe;
}
}
}
public static object HookAuthentication(this OwinRequest request, IAuthenticationHandler handler)
{
var chained = request.Get <AuthenticateDelegate>("security.Authenticate");
var hook = new Hook(handler, chained);
request.Set <AuthenticateDelegate>("security.Authenticate", hook.Authenticate);
return(hook);
}
public OwinCommunicationContext(IOwinContext nativeContext,ILogger logger)
{
PipelineData = new PipelineData();
_nativeContext = nativeContext;
Request = new OwinRequest(nativeContext.Request);
Response = new OwinResponse(nativeContext);
ServerErrors = new ServerErrorList { Log = logger };
User = nativeContext.Request.User;
}
/// <summary>
/// Create a new context with only request and response header collections.
/// </summary>
public OwinContext()
{
IDictionary <string, object> environment = new Dictionary <string, object>(StringComparer.Ordinal);
environment[OwinConstants.RequestHeaders] = new Dictionary <string, string[]>(StringComparer.OrdinalIgnoreCase);
environment[OwinConstants.ResponseHeaders] = new Dictionary <string, string[]>(StringComparer.OrdinalIgnoreCase);
Environment = environment;
Request = new OwinRequest(environment);
Response = new OwinResponse(environment);
}
public Task Invoke(IDictionary<string, object> env)
{
var request = new OwinRequest(env);
var response = new OwinResponse(env);
// The forms auth module has a bug where it null refs on a null Extra
var headers = request.Get<IDictionary<string, string[]>>(Owin.Types.OwinConstants.RequestHeaders);
var cookies = request.GetCookies();
string cookieValue;
if (cookies != null && cookies.TryGetValue("jabbr.id", out cookieValue))
{
AuthenticationTicket ticket = _ticketHandler.Unprotect(cookieValue);
if (ticket != null && ticket.Extra == null)
{
var extra = new AuthenticationExtra();
extra.IsPersistent = true;
extra.IssuedUtc = DateTime.UtcNow;
extra.ExpiresUtc = DateTime.UtcNow.AddDays(30);
var newTicket = new AuthenticationTicket(ticket.Identity, extra);
var cookieBuilder = new StringBuilder();
foreach (var cookie in cookies)
{
string value = cookie.Value;
if (cookie.Key == "jabbr.id")
{
// Create a new ticket preserving the identity of the user
// so they don't get logged out
value = _ticketHandler.Protect(newTicket);
response.AddCookie("jabbr.id", value, new CookieOptions
{
Expires = extra.ExpiresUtc.Value.UtcDateTime,
HttpOnly = true
});
}
if (cookieBuilder.Length > 0)
{
cookieBuilder.Append(";");
}
cookieBuilder.Append(cookie.Key)
.Append("=")
.Append(Uri.EscapeDataString(value));
}
headers["Cookie"] = new[] { cookieBuilder.ToString() };
}
}
return _next(env);
}
public void NoReconnectsAfterFallback()
{
// There was a regression where the SSE transport would try to reconnect after it times out.
// This test ensures that no longer happens.
// #2180
using (var host = new MemoryHost())
{
var myReconnect = new MyReconnect();
host.Configure(app =>
{
Func<AppFunc, AppFunc> middleware = (next) =>
{
return env =>
{
var request = new OwinRequest(env);
var response = new OwinResponse(env);
if (!request.Path.Value.Contains("negotiate") && !request.QueryString.Value.Contains("longPolling"))
{
response.Body = new MemoryStream();
}
return next(env);
};
};
app.Use(middleware);
var config = new ConnectionConfiguration
{
Resolver = new DefaultDependencyResolver()
};
config.Resolver.Register(typeof(MyReconnect), () => myReconnect);
app.MapSignalR<MyReconnect>("/echo", config);
});
var connection = new Connection("http://foo/echo");
using (connection)
{
connection.Start(host).Wait();
// Give SSE an opportunity to reconnect
Thread.Sleep(TimeSpan.FromSeconds(5));
Assert.Equal(connection.State, ConnectionState.Connected);
Assert.Equal(connection.Transport.Name, "longPolling");
Assert.Equal(0, myReconnect.Reconnects);
}
}
}
/// <summary>
/// Create a new wrapper.
/// </summary>
/// <param name="environment">OWIN environment dictionary which stores state information about the request, response and relevant server state.</param>
public OwinContext(IDictionary <string, object> environment)
{
if (environment == null)
{
throw new ArgumentNullException("environment");
}
Environment = environment;
Request = new OwinRequest(environment);
Response = new OwinResponse(environment);
}
public void TestGetClientIpAddressFromOwinContext()
{
var owinContextStub = MockRepository.GenerateMock<OwinContext>();
var owinRequest = new OwinRequest { RemoteIpAddress = "127.0.0.1" };
owinContextStub.Stub(x => x.Request).Return(owinRequest).Repeat.Once();
var httpRequestMessage = new HttpRequestMessage();
httpRequestMessage.Properties.Add("MS_OwinContext", owinContextStub);
var result = httpRequestMessage.GetClientIpAddress();
Assert.That(result, Is.EqualTo("127.0.0.1"));
}
public Task ProcessRequest(OwinRequest request)
{
byte[] resource = GetResource();
var response = new OwinResponse(request.Environment)
{
ContentType = contentType,
ContentLength = resource.Length
};
return response.WriteAsync(resource);
}
public string GetCommandName()
{
var request = new OwinRequest(OwinRequestScopeContext.Current.Environment);
var commandHeader = request.Headers.FirstOrDefault(x => x.Key.Equals(CommandHeaderKey, StringComparison.InvariantCultureIgnoreCase));
if (commandHeader.Key != null)
{
var commandName = commandHeader.Value.Single();
return commandName;
}
return null;
}
public string GetCommandName(IDictionary<string, object> environment)
{
var request = new OwinRequest(environment);
var commandHeader = request.Headers.FirstOrDefault(x => x.Key.Equals(CommandHeaderKey, StringComparison.InvariantCultureIgnoreCase));
if (commandHeader.Key != null)
{
var commandName = commandHeader.Value.Single();
return commandName;
}
return null;
}
public Task Invoke(IDictionary<string, object> env)
{
var request = new OwinRequest(env);
var response = new OwinResponse(env);
string cookieValue = request.Cookies["jabbr.id"];
if (!String.IsNullOrEmpty(cookieValue))
{
AuthenticationTicket ticket = _ticketHandler.Unprotect(cookieValue);
if (ticket != null && ticket.Extra == null)
{
var extra = new AuthenticationExtra();
extra.IsPersistent = true;
extra.IssuedUtc = DateTime.UtcNow;
extra.ExpiresUtc = DateTime.UtcNow.AddDays(30);
var newTicket = new AuthenticationTicket(ticket.Identity, extra);
var cookieBuilder = new StringBuilder();
foreach (var cookie in request.Cookies)
{
string value = cookie.Value;
if (cookie.Key == "jabbr.id")
{
// Create a new ticket preserving the identity of the user
// so they don't get logged out
value = _ticketHandler.Protect(newTicket);
response.Cookies.Append("jabbr.id", value, new CookieOptions
{
Expires = extra.ExpiresUtc.Value.UtcDateTime,
HttpOnly = true
});
}
if (cookieBuilder.Length > 0)
{
cookieBuilder.Append(";");
}
cookieBuilder.Append(cookie.Key)
.Append("=")
.Append(Uri.EscapeDataString(value));
}
request.Headers["Cookie"] = cookieBuilder.ToString();
}
}
return _next(env);
}
public Task Invoke(IDictionary<string, object> env)
{
var request = new OwinRequest(env);
// This header is set on app harbor since ssl is terminated at the load balancer
var scheme = request.Headers.Get("X-Forwarded-Proto");
if (!String.IsNullOrEmpty(scheme))
{
request.Scheme = scheme;
}
return _next(env);
}
public string GetCommandName(IDictionary<string, object> environment)
{
var request = new OwinRequest(environment);
var commandEndpointPath = (PathString) environment["CommandEndpointPath"];
var requestPath = new PathString(request.Uri.LocalPath);
PathString remainingPath;
if (requestPath.StartsWithSegments(commandEndpointPath, out remainingPath))
{
var commandName = remainingPath.Value.TrimStart('/');
return commandName;
}
return null;
}
public object Create(Type commandType, IDictionary<string, object> environment)
{
var request = new OwinRequest(environment);
using (var streamReader = new StreamReader(request.Body))
{
var requestBody = streamReader.ReadToEnd();
try
{
var command = Convert.ChangeType(JsonConvert.DeserializeObject(requestBody, commandType), commandType);
return command;
}
catch (JsonReaderException ex)
{
throw new CommandConstructionException(commandType, requestBody, ex);
}
}
}
public string GetCommandName()
{
var environment = OwinRequestScopeContext.Current.Environment;
var request = new OwinRequest(environment);
var commandEndpointPath = (PathString) environment["CommandEndpointPath"];
var requestPath = new PathString(request.Uri.LocalPath);
PathString remainingPath;
if (requestPath.StartsWithSegments(commandEndpointPath, out remainingPath))
{
var commandName = remainingPath.Value.TrimStart('/');
return commandName;
}
return null;
}
public Task Invoke(IDictionary<string, object> env)
{
var request = new OwinRequest(env);
var response = new OwinResponse(env);
if (request.Uri.Scheme.Equals("https", StringComparison.OrdinalIgnoreCase))
return _next(env);
var builder = new UriBuilder(request.Uri) { Scheme = "https" };
if (request.Uri.IsDefaultPort)
builder.Port = -1;
response.Headers.Set("Location", builder.ToString());
response.StatusCode = (int)HttpStatusCode.Found;
return TaskHelper.Empty;
}
public async Task InitMessageSentToFallbackTransports()
{
using (var host = new MemoryHost())
{
host.Configure(app =>
{
Func<AppFunc, AppFunc> middleware = (next) =>
{
return env =>
{
var request = new OwinRequest(env);
var response = new OwinResponse(env);
if (!request.Path.Value.Contains("negotiate") && !request.QueryString.Value.Contains("longPolling"))
{
response.Body = new MemoryStream();
}
return next(env);
};
};
app.Use(middleware);
var config = new ConnectionConfiguration
{
Resolver = new DefaultDependencyResolver()
};
app.MapSignalR<MyConnection>("/echo", config);
});
var connection = new Connection("http://foo/echo");
using (connection)
{
await connection.Start(host);
Assert.Equal(connection.State, ConnectionState.Connected);
Assert.Equal(connection.Transport.Name, "longPolling");
}
}
}
public Task ProcessRequest(OwinRequest request)
{
var result = action(GetRequestParams(request));
var json = JsonConvert.SerializeObject(result);
var jsonBytes = Encoding.UTF8.GetBytes(json);
var response = new OwinResponse(request.Environment)
{
Headers =
{
{"Cache-Control", new []{"no-store", "no-cache"}},
{"Pragma", new []{"no-cache"}}
},
ContentType = "application/json;charset=utf-8",
ContentLength = jsonBytes.Length
};
return response.WriteAsync(jsonBytes);
}
public override Task ProcessRequest(HostContext context)
{
string redirectWhen = "____Never____";
if (!String.IsNullOrEmpty(context.Request.QueryString["redirectWhen"]))
{
redirectWhen = context.Request.QueryString["redirectWhen"];
}
var owinRequest = new OwinRequest(context.Environment);
if (owinRequest.Path.Value.Contains("/" + redirectWhen))
{
var response = new OwinResponse(context.Environment);
// Redirect to an invalid page
response.Redirect("http://" + owinRequest.Host);
return TaskAsyncHelper.Empty;
}
return base.ProcessRequest(context);
}
/// <summary>
/// Creates request OWIN respresentation.
/// </summary>
/// <param name="method">The request method.</param>
/// <param name="scheme">The request scheme.</param>
/// <param name="pathBase">The request base path.</param>
/// <param name="path">The request path.</param>
/// <param name="headers">The request headers.</param>
/// <param name="queryString">The request query string</param>
/// <param name="requestBody">The body of request.</param>
/// <returns>OWIN representation for provided request parameters.</returns>
private static Dictionary<string, object> CreateOwinEnvironment(string method, string scheme, string pathBase,
string path, IDictionary<string, string[]> headers, string queryString = "", byte[] requestBody = null)
{
var environment = new Dictionary<string, object>(StringComparer.Ordinal);
environment[CommonOwinKeys.OwinCallCancelled] = new CancellationToken();
#region OWIN request params
var request = new OwinRequest(environment)
{
Method = method,
Scheme = scheme,
Path = new PathString(path),
PathBase = new PathString(pathBase),
QueryString = new QueryString(queryString),
Body = new MemoryStream(requestBody ?? new byte[0]),
Protocol = Protocols.Http1
};
// request.Headers is readonly
request.Set(CommonOwinKeys.RequestHeaders, headers);
#endregion
#region set default OWIN response params
var response = new OwinResponse(environment) {Body = new MemoryStream(), StatusCode = StatusCode.Code200Ok};
//response.Headers is readonly
response.Set(CommonOwinKeys.ResponseHeaders, new Dictionary<string, string[]>(StringComparer.OrdinalIgnoreCase));
#endregion
return environment;
}
public override Task Invoke(OwinRequest request, OwinResponse response)
{
return _appFunc.Invoke(response.Environment);
}
public bool Equals(OwinRequest other)
{
return(Equals(_request, other._request));
}
public abstract Task Invoke(OwinRequest request, OwinResponse response);
public RequestHandler(IDictionary<string, object> owinEnvironment)
{
Console.WriteLine("RequestHandler ctor");
OwinRequest req = new OwinRequest(owinEnvironment);
Console.WriteLine(req.Uri.AbsoluteUri);
}
public OwinResponse(OwinRequest request) : this(request.Environment)
{
}
public override Task Invoke(OwinRequest request, OwinResponse response)
{
response.AddHeader("X-ApplicationVersion", BuildInfo.Version.ToString());
return Next.Invoke(request, response);
}
public static void UnhookAuthentication(this OwinRequest request, object state)
{
var hook = (Hook)state;
request.Set("security.Authenticate", hook.Chained);
}
public RazorRequest(IDictionary<string, object> environment)
{
_request = new OwinRequest(environment);
}
public OwinResponse(OwinRequest request) : this(request.Environment)
{
}
public virtual Task Invoke(OwinRequest request, OwinResponse response)
{
return(Next.Invoke(request, response));
}