public async Task Invoke(IDictionary <string, object> env) { var requestPath = (string)env["owin.RequestPath"]; requestPath = PathUtil.CheckRequestPath(requestPath, options.DefaultFile); var filePath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, options.RootDirectory, requestPath); var fileTag = options.ETagProvider.GetETag(filePath); var requestHeaders = (IDictionary <string, string[]>)env["owin.RequestHeaders"]; if (!string.IsNullOrEmpty(fileTag)) { if (requestHeaders.ContainsKey("If-None-Match")) { var tagValue = requestHeaders["If-None-Match"]; if (tagValue != null && tagValue.Length > 0) { if (options.ETagProvider.CompareETag(filePath, tagValue[0])) { env["owin.ResponseStatusCode"] = (int)HttpStatusCode.NotModified; env["owin.ResponseReasonPhrase"] = "Not Modified"; return; } } } else { await next.Invoke(env); var responseHeaders = (IDictionary <string, string[]>)env["owin.ResponseHeaders"]; responseHeaders["ETag"] = new [] { fileTag }; return; } } await next.Invoke(env); }
public async Task Invoke(IDictionary <string, Object> environment) { IOwinContext context = new OwinContext(environment); context.Get <TextWriter>("host.TraceOutput").WriteLine("Currently in ActiveDirectory authentication middleware"); var debug = true; if (ActiveDirectoryLogin("x", "x", debug)) { // _next is only invoked if authentication succeeds: context.Response.StatusCode = 200; context.Response.ReasonPhrase = "OK"; await _next.Invoke(environment); } else { context.Response.StatusCode = 401; context.Response.ReasonPhrase = "Not Authorized"; await context.Response.WriteAsync(string.Format("<h1>Error {0}-{1}", context.Response.StatusCode, context.Response.ReasonPhrase)); } }
public AppFunc AuthenticationMiddleWare(AppFunc next) { AppFunc appFunc = async(IDictionary <string, object> environment) => { IOwinContext context = new OwinContext(environment); string[] query = context.Request.QueryString.Value.Split(Convert.ToChar(PARAGRAPH_SEPARATOR)); var isAuthorized = query[0] == AUTHENTICATION_CODE; if (!isAuthorized) { context.Response.StatusCode = 401; context.Response.ReasonPhrase = "Not Authorized"; // Send back an error page: await context.Response.WriteAsync(string.Format("<h1>Error {0}-{1}", context.Response.StatusCode, context.Response.ReasonPhrase)); } else { // we will only continue if authentication succeeds: context.Response.StatusCode = 200; context.Response.ReasonPhrase = "OK"; await next.Invoke(environment); } }; return(appFunc); }
public async Task Invoke(IDictionary <string, object> environment) { IOwinContext context = new OwinContext(environment); await context.Response.WriteAsync(_message); await _next.Invoke(environment); }
public async Task Invoke(IDictionary <string, object> environment) { // get owin context from environment IOwinContext context = new OwinContext(environment); // check for token. var user = context.Authentication.User; if (user != null) { // if there was a token and user is set, make sure claims are up to date var issuedUtc = new DateTime(long.Parse(user.FindFirst(OwinKeys.Ticks).Value)); var id = int.Parse(user.FindFirst(OwinKeys.AuthUserId).Value); var role = int.Parse(user.FindFirst(OwinKeys.UserRoleId).Value); if (!_roleManager.CheckRoleTimes(id, role, issuedUtc)) { if (role > 0) { // reject - add inidcation header context.Response.Headers.Add("Access-Control-Expose-Headers", new[] { "X-Update-Roles" }); context.Response.Headers.Add("X-Update-Roles", new[] { "true" }); } // manually add cors header for this response context.Response.Headers.Add("Access-Control-Allow-Origin", new[] { AppSettings.GetAdminSite() }); context.Response.StatusCode = (int)HttpStatusCode.Unauthorized; return; } } await _next.Invoke(environment); }
/// <summary> /// See interface docs. /// </summary> /// <param name="next"></param> /// <returns></returns> public AppFunc HandleRequest(AppFunc next) { AppFunc appFunc = async(IDictionary <string, object> environment) => { try { await next.Invoke(environment); } catch (Exception ex) { try { var context = PipelineContext.GetOrCreate(environment); var log = Factory.ResolveSingleton <ILog>(); log.WriteLine($"Exception caught during handling of request {context.Request.Uri}: {ex}"); } catch { } if (environment != null) { if (environment.ContainsKey("owin.ResponseStatusCode")) { environment["owin.ResponseStatusCode"] = 500; } else { environment.Add("owin.ResponseStatusCode", 500); } } } }; return(appFunc); }
private async void ProcessRequest(HttpListenerContext context, AppFunc app, OwinLogger logger) { OwinHttpListenerContext owinContext = null; try { GetPathAndQuery(context.Request, out var pathBase, out var path, out var query); owinContext = new OwinHttpListenerContext(context, pathBase, path, query); await app.Invoke(owinContext.Environment); if (!context.Connection.IsClosed) { owinContext.Response.CompleteResponse(); } owinContext.Response.Close(); owinContext.End(); owinContext.Dispose(); } catch (Exception ex) { if (owinContext != null) { owinContext.End(ex); owinContext.Dispose(); } } }
public async Task Invoke(IDictionary <string, object> environment) { IOwinContext context = new OwinContext(environment); // If this is a logging request (based on its url), do the logging and don't pass on the request // to the rest of the pipeline. if (LoggingUrlHelpers.IsLoggingUrl(context.Request.Uri.OriginalString)) { try { ProcessRequest(context); } catch { // An exception was thrown while processing a log request. // Just eat it here, seeing there doesn't seem to be an easy and reliable way // to log the exception. } return; } // It was not a logging request await _next.Invoke(environment); }
public async Task Invoke(IDictionary <string, object> environment) { IOwinContext context = new OwinContext(environment); // In the real world we would do REAL auth processing here... var isAuthorized = context.Request.QueryString.Value == "ahmed"; if (!isAuthorized) { context.Response.StatusCode = 401; context.Response.ReasonPhrase = "Not Authorized"; // Send back a really silly error page: await context.Response.WriteAsync(string.Format("<h1>Error {0}-{1}", context.Response.StatusCode, context.Response.ReasonPhrase)); } else { // _next is only invoked is authentication succeeds: context.Response.StatusCode = 200; context.Response.ReasonPhrase = "OK"; await _next.Invoke(environment); } }
public async Task Invoke(Env environment) { if (IsCallToHealthCheck(environment)) { var responseHeaders = (IDictionary <string, string[]>)environment["owin.ResponseHeaders"]; responseHeaders["Content-Type"] = new[] { Constants.Response.ContentType.Json + "; charset=utf-8" }; var responseStream = (Stream)environment["owin.ResponseBody"]; var healthCheckService = new HealthCheckService(configuration, new VersionProvider(configuration), systemCheckerResolverFactory()); var result = healthCheckService.CheckHealth(IsIntrusive(environment)); using (var writeStream = new MemoryStream()) { var contentLength = new HealthResultJsonSerializer().SerializeToStream(writeStream, result); responseHeaders["Content-Length"] = new[] { contentLength.ToString("D") }; writeStream.Position = 0; await writeStream.CopyToAsync(responseStream); } } else { await next.Invoke(environment); } }
public async Task Invoke(IDictionary <string, object> environment) { if (environment == null) { throw new ArgumentNullException(nameof(environment)); } var envCopy = environment; var context = new OwinContext(environment); var userPrincipal = context.Authentication.User; var newUserClaims = ReadyNewClaimsList(userPrincipal); if (_options.UseCaching) { newUserClaims.AddRange(await _options.ClaimsCacheManager.GetClaimsFromCache(context)); } else { var newClaims = await _options.ProviderRunner.RunAllProviderTasksAsync(envCopy, _options.Providers); await _options.ClaimsCacheManager.SetClaimsInCache(context, newClaims); newUserClaims.AddRange(newClaims); } var identity = new ClaimsIdentity(newUserClaims, context.Authentication.User.Identity.AuthenticationType); var newPrincipal = new ClaimsPrincipal(identity); context.Request.User = newPrincipal; await _next.Invoke(environment); }
protected override Task Invoke( IDictionary <string, object> env, HttpRequestMessage requestMessage, CancellationToken cancellationToken) { return(_next.Invoke(env)); }
public async Task Invoke(IDictionary <string, object> env) { Console.WriteLine("{0} {1} {2}", DateTime.Now, env["owin.RequestMethod"], env["owin.RequestPath"]); await next.Invoke(env); Console.WriteLine("Return HTTP status: {0}", env["owin.ResponseStatusCode"]); }
public async Task Invoke(IDictionary <string, object> environment) { IOwinContext context = new OwinContext(environment); await context.Response.WriteAsync("<h1>Middleware 3 triggered</h1>"); await _next.Invoke(environment); }
public async Task Invoke(IDictionary <string, object> envionment) { await _next.Invoke(envionment); IOwinContext owinContext = new OwinContext(envionment); Console.WriteLine($"URI: {owinContext.Request.Uri} Status Code: {owinContext.Response.StatusCode}"); }
public async Task Invoke(IDictionary <string, object> env) { var owinContext = new OwinContext(env); Debug.WriteLine($"incoming Request Path:{owinContext.Request.Path}"); await _next.Invoke(env); Debug.WriteLine($"outgoing Respose path{owinContext.Request.Path}"); }
public async Task Invoke(IDictionary <string, object> env) { // inbound IOwinContext context = new OwinContext(env); await context.Response.WriteAsync("<h1>Hello from My 2nd Middleware</h1>"); // call next middleware func await _next.Invoke(env); }
public async Task Invoke(IDictionary <string, Object> environment) { await _next.Invoke(environment); IOwinContext context = new OwinContext(environment); await context.Response.WriteAsync($"<h1>{_options.GetGreetingsfromUser()}</h1>"); context.Response.StatusCode = 200; context.Response.ReasonPhrase = "OK"; }
public async Task Invoke(IDictionary <string, object> environment) { // Pass everything up through the pipeline first: await _next.Invoke(environment); // Do the logging on the way out: IOwinContext context = new OwinContext(environment); Console.WriteLine("URI: {0} Status Code: {1}", context.Request.Uri, context.Response.StatusCode); }
static AppFunc LoggingMiddleware(AppFunc next) { return(async environment => { Console.WriteLine("Receiving request for \"{0}\"", environment["owin.RequestPath"]); await next.Invoke(environment); Console.WriteLine("Returning with status {0}", environment["owin.ResponseStatusCode"]); }); }
/// <summary> /// See interface docs. /// </summary> /// <param name="next"></param> /// <returns></returns> public AppFunc HandleRequest(AppFunc next) { AppFunc appFunc = async(IDictionary <string, object> environment) => { if (AddCorsHeaders(environment)) { await next.Invoke(environment); } }; return(appFunc); }
/// <summary> /// See interface docs. /// </summary> /// <param name="next"></param> /// <returns></returns> public AppFunc FilterRequest(AppFunc next) { AppFunc appFunc = async(IDictionary <string, object> environment) => { if (Authenticated(environment)) { await next.Invoke(environment); } }; return(appFunc); }
private AppFunc HandleRequest(AppFunc next) { AppFunc appFunc = async(IDictionary <string, object> environment) => { var context = PipelineContext.GetOrCreate(environment); if (!ProcessRequest(context)) { await next.Invoke(environment); } }; return(appFunc); }
// {Microsoft.Owin.Host.SystemWeb.CallEnvironment.AspNetDictionary} public Task Invoke(IDictionary <string, object> environment) { PrintMessage("TypeMiddleWare invoke"); UpdateInvokeCount(environment); if (_next != null) { return(_next.Invoke(environment)); } var context = new OwinContext(environment); return(_middleware.Invoke(context)); }
/// <summary> /// See interface docs. /// </summary> /// <param name="next"></param> /// <returns></returns> public AppFunc HandleRequest(AppFunc next) { AppFunc appFunc = async(IDictionary <string, object> environment) => { var context = PipelineContext.GetOrCreate(environment); if (!ServeFromFileSystem(environment)) { await next.Invoke(environment); } }; return(appFunc); }
private static AppFunc InterfaceMiddleware(AppFunc next) { AppFunc appFunc = async(IDictionary <string, object> dic) => { IOwinContext context = new OwinContext(dic); await context.Response.WriteAsync("usando a IOwinContext <br>"); await next.Invoke(dic); }; return(appFunc); }
public Task Invoke(IDictionary <string, object> env) { var path = env[OwinConstants.RequestPath].ToString(); if (urls.Any(path.StartsWith)) { return(fileServer.Invoke(env)); } else { return(app.Invoke(env)); } }
public AppFunc AuthMiddleWare(AppFunc next) { AppFunc appFunc = async (IDictionary<string, object> environment) => { var response = environment["owin.ResponseBody"] as Stream; using (var writer = new StreamWriter(response)) { // await writer.WriteAsync("<h1>Hello from My First Middleware</h1>"); } await next.Invoke(environment); }; return appFunc; }
public async Task InvokeAsync(IDictionary <string, object> context) { if (context["owin.RequestPath"] as string == "/") { using (var writer = new StreamWriter(context["owin.ResponseBody"] as Stream)) { await writer.WriteAsync("Hello World!"); } } else { await next.Invoke(context); } }
// Este método é um middleware. private static AppFunc MetodoTrataRequisicaoMiddleware(AppFunc next) { return( // Contexto é um dicionário que contém toda a informação sobre a requisição. async context => { using (var sw = new StreamWriter((Stream)context["owin.ResponseBody"])) { await sw.WriteAsync("usando o metodo Use <br>"); } await next.Invoke(context); } ); }
public async Task Invoke(IDictionary <string, object> environment) { // If there is no next component, a 404 Not Found will be written as the response code here: await _next.Invoke(environment); IOwinContext context = new OwinContext(environment); // Insert the _greeting into the display text: await context.Response.WriteAsync(string.Format("<h1>{0}</h1>", _configOptions.GetGreeting())); // Update the response code to 200 OK: context.Response.StatusCode = 200; context.Response.ReasonPhrase = "OK"; }
private async Task Invoke(AppFunc next, IDictionary<string, object> env) { Console.WriteLine("Begin #3"); await next.Invoke(env); Console.WriteLine("End #3"); }