public async Task Invoke(IDictionary<string, object> environment) { int maxRedirects = _maxRedirects; while (maxRedirects >= 0) { await _next(environment); var response = new OwinResponse(environment); if (response.StatusCode == 302 || response.StatusCode == 301) { string url = BuildRedirectUrl(response); // Clear the env so we can make a new request environment.Clear(); // Populate the env with new request data RequestBuilder.BuildGet(environment, url); } else { break; } maxRedirects--; } }
public Task Invoke(IDictionary<string, object> env) { var request = new OwinRequest(env); var logger = _kernel.Get<ILogger>(); var requestHeaders = new StringBuilder(); foreach (var header in request.Headers) { requestHeaders.AppendLine(header.Key + " = " + request.GetHeader(header.Key)); } Task task = _next(env); var response = new OwinResponse(env); var responseHeaders = new StringBuilder(); foreach (var header in response.Headers) { responseHeaders.AppendLine(header.Key + " = " + response.GetHeader(header.Key)); } logger.Log("URI: " + request.Uri + " " + Environment.NewLine + "Request Headers: \r\n " + requestHeaders.ToString() + Environment.NewLine + "Response Headers: \r\n " + responseHeaders.ToString()); return task; }
private void SetHttp2UpgradeHeadersAndStatusCode(OwinResponse owinResponse) { owinResponse.StatusCode = 101; owinResponse.ReasonPhrase = "Switching Protocols"; owinResponse.SetHeader("Connection", "Upgrade"); owinResponse.SetHeader("Upgrade", "HTTP/2.0"); }
protected override Task<HttpResponseMessage> SendAsync( HttpRequestMessage request, CancellationToken cancellationToken) { OwinRequest owinRequest = OwinRequest.Create(); owinRequest.Scheme = request.RequestUri.Scheme; owinRequest.Method = request.Method.ToString(); owinRequest.Path = request.RequestUri.AbsolutePath; owinRequest.QueryString = request.RequestUri.Query.TrimStart('?'); owinRequest.CallCancelled = cancellationToken; foreach (var header in request.Headers) { owinRequest.AddHeaderUnmodified(header.Key, header.Value); } HttpContent requestContent = request.Content; if (requestContent != null) { foreach (var header in request.Content.Headers) { owinRequest.AddHeaderUnmodified(header.Key, header.Value); } } else { requestContent = new StreamContent(Stream.Null); } return requestContent.ReadAsStreamAsync() .Then(requestBody => { owinRequest.Body = requestBody; var responseMemoryStream = new MemoryStream(); var owinResponse = new OwinResponse(owinRequest) { Body = responseMemoryStream }; return _invoke.Invoke(owinRequest.Dictionary) .Then(() => { var response = new HttpResponseMessage(); response.StatusCode = (HttpStatusCode)owinResponse.StatusCode; response.ReasonPhrase = owinResponse.ReasonPhrase; response.RequestMessage = request; // response.Version = owinResponse.Protocol; responseMemoryStream.Seek(0, SeekOrigin.Begin); response.Content = new StreamContent(responseMemoryStream); foreach (var header in owinResponse.Headers) { if (!response.Headers.TryAddWithoutValidation(header.Key, header.Value)) { response.Content.Headers.TryAddWithoutValidation(header.Key, header.Value); } } return response; }); }); }
public Task Invoke(IDictionary<string, object> environment) { var request = new OwinRequest(environment); if (string.IsNullOrEmpty(_options.Path) || string.Equals(request.Path, _options.Path, StringComparison.OrdinalIgnoreCase)) { // TODO: Make it pretty OwinResponse response = new OwinResponse(environment); response.ContentType = "text/html"; StringBuilder builder = new StringBuilder(); builder.AppendLine("<html>") .AppendLine("<head>") .AppendLine("<title>") .AppendLine("Welcome") .AppendLine("</title>") .AppendLine("</head>") .AppendLine("<body>") .AppendLine("<H1>Welcome</H1>") .AppendLine("<p>You have reached the default application page.</p>") .AppendLine("<H4>Additional Resources:</H4>") .AppendLine("<ul>") .AppendLine("<li><a href=\"http://katanaproject.codeplex.com/\">Katana Project</a>") .AppendLine("<li><a href=\"http://www.owin.org/\">owin.org</a>") .AppendLine("</ul>") .AppendLine("</body>") .AppendLine("</html>"); return response.WriteAsync(builder.ToString()); } return _next(environment); }
public async Task Invoke(IDictionary<string, object> environment) { await _next(environment); var response = new OwinResponse(environment); if (response.Body == Stream.Null) { return; } string connection = response.GetHeader("Connection"); if (response.Protocol.Equals("HTTP/1.1", StringComparison.OrdinalIgnoreCase) && String.Equals(connection, "Close", StringComparison.OrdinalIgnoreCase)) { var ms = new MemoryStream(); using (response.Body) { await response.Body.CopyToAsync(ms).ConfigureAwait(continueOnCapturedContext: false); } ms.Seek(0, SeekOrigin.Begin); response.Body = ms; } }
public async Task Invoke(IDictionary<string, object> env) { var request = new OwinRequest(env); var response = new OwinResponse(env); int id; if (int.TryParse(request.Path.Substring(1), out id)) { switch (request.Method) { case "GET": var job = await _jobList.GetJob(id); JsonSerializer.SerializeToStream(job, response.Body); break; case "DELETE": _jobList.DeleteJob(id); break; default: throw new NotImplementedException(); } } else { JsonSerializer.SerializeToStream(await _jobList.ListJobs(), response.Body); } }
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.SetHeader("Location", builder.ToString()); response.StatusCode = 302; return TaskAsyncHelper.Empty; } else { return _next(env); } }
public void Init() { table = new Mock<IRouteTable>(); renderer = new Mock<IRazorRenderer>(); request = new OwinRequest(new Dictionary<string, object>()); response = new OwinResponse(new Dictionary<string, object>()) { Headers = new Dictionary<string, string[]>(), Body = new MemoryStream() }; middleware = new RazorMiddleware(table.Object, renderer.Object); }
Task UpgradeToWebSockets(OwinRequest request, OwinResponse response, Func<Task> next) { if (!request.CanAccept) return next(); request.Accept(WebSocketEcho); return Task.FromResult<object>(null); }
public Task Invoke(IDictionary<string, object> env) { var request = new OwinRequest(env); var response = new OwinResponse(env); if (!request.IsLocal) { response.StatusCode = (int)HttpStatusCode.ServiceUnavailable; return Task.FromResult(0); } return _next(env); }
private static void RewindResponseBody(IDictionary<string, object> environment) { var response = new OwinResponse(environment); var ms = response.Body as MemoryStream; if (ms != null) { // Rewind ms.Seek(0, SeekOrigin.Begin); } }
private static Task InvokeHandler(OwinResponse res, Func<OwinRequest, object> routeHandler, OwinRequest req) { var result = routeHandler(req); var flaskyResponse = result as IResponse; if(flaskyResponse != null) { return flaskyResponse.Write(res); } res.ContentType = "text/plain"; return res.WriteAsync(result.ToString()); }
public Task Invoke(IDictionary<string, object> environment) { var request = new OwinRequest(environment); if (_routeMatcher.HasMatch(request)) { var response = new OwinResponse(environment); var routeHandler = _routeMatcher.GetMatch(request); return InvokeHandler(response, routeHandler, request); } return _next(environment); }
public StaticCompressionContext(IDictionary<string, object> environment, StaticCompressionOptions options, IEncoding encoding, ICompressedStorage storage) { _environment = environment; _options = options; _encoding = encoding; _encodingSuffix = "^" + _encoding.Name; _encodingSuffixQuote = "^" + _encoding.Name + "\""; _storage = storage; _request = new OwinRequest(environment); _response = new OwinResponse(environment); }
public Task Invoke(IDictionary<string, object> environment) { var request = new OwinRequest(environment); if (string.IsNullOrEmpty(_options.Path) || string.Equals(request.Path, _options.Path, StringComparison.OrdinalIgnoreCase)) { // TODO: Make it pretty OwinResponse response = new OwinResponse(environment); response.ContentType = "text/plain"; return response.WriteAsync("Welcome to Katana"); } return _next(environment); }
public async Task Invoke(IDictionary<string, object> environment) { await _next(environment); var response = new OwinResponse(environment); var encoding = response.GetHeader("Content-Encoding"); if (String.Equals(encoding, "gzip", StringComparison.OrdinalIgnoreCase)) { response.Body = new GZipStream(response.Body, CompressionMode.Decompress); } }
public Task Invoke(IDictionary<string, object> environment) { OwinRequest request = new OwinRequest(environment); OwinResponse response = new OwinResponse(environment); response.ContentType = "text/plain"; string responseText = request.GetHeader("breadcrumbs") + "\r\n" + "PathBase: " + request.PathBase + "\r\n" + "Path: " + request.Path + "\r\n"; return response.WriteAsync(responseText); }
// Invoked once per request. public Task Invoke(IDictionary<string, object> environment) { OwinResponse owinResponse = new OwinResponse(environment); string responseText = "Hello World"; byte[] responseBytes = Encoding.UTF8.GetBytes(responseText); owinResponse.SetHeader("Content-Length", responseBytes.Length.ToString(CultureInfo.InvariantCulture)); owinResponse.SetHeader("Content-Type", "text/plain"); return owinResponse.Body.WriteAsync(responseBytes, 0, responseBytes.Length); // return Task.FromResult<object>(null); }
public async Task Invoke(IDictionary<string, object> environment) { var request = new OwinRequest(environment); Uri uri = request.Uri; // Create a stream for the host and port so we can send the request Stream stream = await _streamFactory.CreateStream(uri).ConfigureAwait(continueOnCapturedContext: false); var requestWriter = new StreamWriter(stream); // Request line requestWriter.WriteLine("{0} {1} {2}", request.Method, uri.LocalPath, request.Protocol); // Write headers foreach (var header in request.Headers) { requestWriter.WriteLine("{0}: {1}", header.Key, request.GetHeader(header.Key)); } // End headers requestWriter.WriteLine(); if (request.Body == null) { // End request requestWriter.WriteLine(); } // Flush buffered content to the stream async await requestWriter.FlushAsync().ConfigureAwait(continueOnCapturedContext: false); if (request.Body != null) { // Copy the body to the request await request.Body.CopyToAsync(stream).ConfigureAwait(continueOnCapturedContext: false); } var response = new OwinResponse(environment); // Parse the response HttpParser.ParseResponse(stream, (protocol, statusCode, reasonPhrase) => { response.Protocol = protocol; response.StatusCode = statusCode; response.ReasonPhrase = reasonPhrase; }, (key, value) => response.SetHeader(key, value)); // Set the body to the rest of the stream response.Body = stream; }
private static OwinRequest CreateRequest(string url, string method) { var uri = new Uri(url); var request = OwinRequest.Create(); request.Protocol = "HTTP/1.1"; request.Method = method; // Setup a empty stream by default var response = new OwinResponse(request); response.Body = new MemoryStream(); BuildRequestFromUri(request, uri); return request; }
private static async Task SendFileToResponse(OwinResponse response, CrossAppDomainResponseFile file) { if(response.CanSendFile) { await response.SendFileAsync(file.Path, file.Length, file.Offset, CancellationToken.None); return; } var buffer = new byte[file.Length - file.Offset]; using (var stream = File.OpenRead(file.Path)) { stream.Seek(file.Offset, SeekOrigin.Begin); await stream.ReadAsync(buffer, 0, (int)file.Length); } await response.WriteAsync(buffer); }
public async Task Invoke(IDictionary<string, object> env) { OwinRequest request = new OwinRequest(env); if (request.Path == "/raw") { OwinResponse response = new OwinResponse(request); response.ContentType = "text/plain"; await response.WriteAsync("Hello from OWIN!"); } else { await _nextFunc(env); } }
public async Task ScriptFileCanBeExecutedByName() { var factory = new RoslynAppLoaderFactory(); Func<string, Action<IAppBuilder>> loader = factory.Create(_ => null); Action<IAppBuilder> startup = loader.Invoke("Simple.csx"); var builder = new AppBuilder(); startup.Invoke(builder); var app = (AppFunc)builder.Build(typeof(AppFunc)); OwinRequest req = OwinRequest.Create(); await app.Invoke(req.Dictionary); var res = new OwinResponse(req); res.StatusCode.ShouldBe(24601); }
public async Task Invoke(IDictionary<string, object> env) { object value; if (env.TryGetValue("server.User", out value)) { var windowsPrincipal = value as WindowsPrincipal; if (windowsPrincipal != null && windowsPrincipal.Identity.IsAuthenticated) { await _next(env); var request = new OwinRequest(env); var response = new OwinResponse(env); if (response.StatusCode == 401) { // We're going no add the identifier claim var nameClaim = windowsPrincipal.FindFirst(ClaimTypes.Name); // This is the domain name string name = nameClaim.Value; // If the name is something like DOMAIN\username then // grab the name part var parts = name.Split(new[] { '\\' }, 2); string shortName = parts.Length == 1 ? parts[0] : parts[parts.Length - 1]; // REVIEW: Do we want to preserve the other claims? // Normalize the claims here var claims = new List<Claim>(); claims.Add(new Claim(ClaimTypes.NameIdentifier, name)); claims.Add(new Claim(ClaimTypes.Name, shortName)); claims.Add(new Claim(ClaimTypes.AuthenticationMethod, "Windows")); var identity = new ClaimsIdentity(claims, Constants.JabbRAuthType); var claimsPrincipal = new ClaimsPrincipal(identity); response.SignIn(claimsPrincipal); response.StatusCode = 302; response.SetHeader("Location", request.PathBase + request.Path); } return; } } await _next(env); }
public static AppFunc Middleware(AppFunc app) { return env => { var request = new OwinRequest(env); var websocketVersion = request.Get<string>(OwinConstants.WebSocket.Version); WebSocketAccept webSocketAccept = request.Get<WebSocketAccept>(OwinConstants.WebSocket.Accept); if (request.CanUpgrade && websocketVersion == null) // If we have opaque support and no WebSocket support yet { if (IsWebSocketRequest(env)) { // TODO: check for correct requested version of WebSocket protocol IDictionary<string, object> acceptOptions = null; WebSocketFunc webSocketFunc = null; // Announce websocket support env[OwinConstants.WebSocket.Accept] = new WebSocketAccept( (options, callback) => { acceptOptions = options; webSocketFunc = callback; env[OwinConstants.ResponseStatusCode] = 101; }); return app(env).ContinueWith(t => { OwinResponse response = new OwinResponse(env); if (response.StatusCode == 101 && webSocketFunc != null) { SetWebSocketResponseHeaders(env, acceptOptions); request.UpgradeDelegate(acceptOptions, opaqueEnv => { WebSocketLayer webSocket = new WebSocketLayer(opaqueEnv); return webSocketFunc(webSocket.Environment) .ContinueWith(tt => webSocket.CleanupAsync()); }); } }); } } // else return app(env); }; }
private string BuildRedirectUrl(OwinResponse response) { string location = response.GetHeader("Location"); Uri uri; if (Uri.TryCreate(location, UriKind.Relative, out uri)) { // If location is relative, we need to build a full url var previousRequest = new OwinRequest(response.Dictionary); var uriBuilder = new UriBuilder(previousRequest.Uri); uriBuilder.Path = location; return uriBuilder.ToString(); } return location; }
private static Task RequestDump(OwinRequest request, OwinResponse response) { var builder = new StringBuilder(); builder.AppendLine("<h1>Katana demo op TechDays</h1>"); builder.AppendLine("<h2>request.Dictionary</h2>"); builder.Append("<table>"); foreach (var item in request.Dictionary) { builder.AppendFormat("<tr><td>{0}</td><td>{1}</td></tr>", item.Key, item.Value); } builder.Append("</table>"); response.ContentType = "text/html"; return response.WriteAsync(builder.ToString()); }
/// <summary></summary> /// <param name="environment"></param> /// <returns></returns> public async Task Invoke(IDictionary<string, object> environment) { OwinRequest request = new OwinRequest(environment); OwinResponse response = new OwinResponse(environment); CancellationToken cancellationToken = request.CallCancelled; AuthenticationHeaderValue authorization; string authorizationHeaderError; if (!TryParseAuthorizationHeader(request, out authorization, out authorizationHeaderError)) { response.StatusCode = 400; cancellationToken.ThrowIfCancellationRequested(); await WriteMessage(authorizationHeaderError, response, cancellationToken); return; } cancellationToken.ThrowIfCancellationRequested(); IBasicAuthenticationResult result = await AuthenticateAsync(authorization, cancellationToken); int errorStatusCode; string errorMessage; if (!TryProcessResult(result, environment, out errorStatusCode, out errorMessage)) { response.StatusCode = errorStatusCode; cancellationToken.ThrowIfCancellationRequested(); await AddChallengeOnUnauthorizedAsync(response, cancellationToken); cancellationToken.ThrowIfCancellationRequested(); await WriteMessage(errorMessage, response, cancellationToken); return; } cancellationToken.ThrowIfCancellationRequested(); AuthenticationHeaderValue challenge = await _protocol.CreateChallengeAsync(cancellationToken); if (!TryRegisterOnSendingHeaders(challenge, request, response, out errorMessage)) { response.StatusCode = 500; cancellationToken.ThrowIfCancellationRequested(); await WriteMessage(errorMessage, response, cancellationToken); return; } cancellationToken.ThrowIfCancellationRequested(); await _next(environment); }
public async Task Invoke(IDictionary<string, object> env) { var httpRequest = new Gate.Request(env); var httpResponse = new OwinResponse(env); string url; Uri uri; if (!httpRequest.Query.TryGetValue("url", out url) || String.IsNullOrEmpty(url) || !Uri.TryCreate(url, UriKind.Absolute, out uri) || !ImageContentProvider.IsValidImagePath(uri) || !IsAuthenticated(env)) { httpResponse.StatusCode = 404; return; } try { var request = (HttpWebRequest)WebRequest.Create(url); request.CachePolicy = new RequestCachePolicy(RequestCacheLevel.Default); var response = (HttpWebResponse)await request.GetResponseAsync(); if (!ImageContentProvider.IsValidContentType(response.ContentType) && response.ContentLength > _settings.ProxyImageMaxSizeBytes) { httpResponse.StatusCode = 404; return; } httpResponse.SetHeader("Content-Type", response.ContentType); httpResponse.StatusCode = (int)response.StatusCode; using (response) { using (Stream stream = response.GetResponseStream()) { await stream.CopyToAsync(httpResponse.Body); } } } catch { httpResponse.StatusCode = 404; } }
public bool Equals(OwinResponse other) { return(Equals(_dictionary, other._dictionary)); }