/// <summary> /// Invokes the middleware. /// </summary> /// <param name="context">The context.</param> /// <param name="router">The router.</param> /// <returns></returns> public async Task Invoke(HttpContext context, IEndpointRouter router, IUserSession session) { // todo: review: right place to call this? await session.EnsureSessionIdCookieAsync(); try { var endpoint = router.Find(context); if (endpoint != null) { _logger.LogInformation("Invoking IdentityServer endpoint: {endpointType} for {url}", endpoint.GetType().FullName, context.Request.Path.ToString()); var result = await endpoint.ProcessAsync(context); if (result != null) { _logger.LogTrace("Invoking result: {type}", result.GetType().FullName); await result.ExecuteAsync(context); } return; } } catch (Exception ex) { await _events.RaiseAsync(new UnhandledExceptionEvent(ex)); _logger.LogCritical("Unhandled exception: {exception}", ex.ToString()); throw; } await _next(context); }
public async Task Invoke(HttpContext context, IEndpointRouter router) { try { var endpoint = router.Find(context); if (endpoint != null) { _logger.LogInformation("Invoking WechatPay endpoint: {endpointType} for {url}", endpoint.GetType().FullName, context.Request.Path.ToString()); var result = endpoint.Process(context); if (result != null) { _logger.LogTrace("Invoking result: {type}", result.GetType().FullName); await result.ExecuteAsync(context); } return; } else { context.Response.StatusCode = StatusCodes.Status404NotFound; } } catch (Exception ex) { _logger.LogCritical(ex, "Unhandled exception: {exception}", ex.Message); } }
public async Task Invoke(HttpContext context, IEndpointRouter router) { try { var endpoint = router.Find(context); if (endpoint != null) { _logger.LogInformation("Invoking IdentityServer endpoint: {endpointType} for {url}", endpoint.GetType().FullName, context.Request.Path.ToString()); var result = await endpoint.ProcessAsync(context); if (result != null) { _logger.LogTrace("Invoking result: {type}", result.GetType().FullName); await result.ExecuteAsync(context); } return; } } catch (Exception ex) { _logger.LogCritical("Unhandled exception: {exception}", ex.ToString()); throw; } await _next(context); }
public async Task InvokeAsync( HttpContext context, RequestDelegate next) { try { var endpointHandler = _endpointRouter.Find(context); if (endpointHandler != null) { _logger.LogInvokingEndpointHandler( endpointHandler .GetType() .Name ?? string.Empty, context.Request.Path.ToString()); var result = await endpointHandler.ProcessAsync(context, context.RequestAborted); _logger.LogInvokingEndpointResult( result.GetType() .Name ?? string.Empty); await result.ExecuteAsync(context, context.RequestAborted); return; } } catch (Exception ex) { _logger.LogUnhandledException(ex); throw; } await next(context); }
/// <summary> /// Invokes the middleware. /// </summary> /// <param name="context">The context.</param> /// <param name="router">The router.</param> /// <param name="session">The user session.</param> /// <param name="events">The event service.</param> /// <returns></returns> public async Task Invoke(HttpContext context, IEndpointRouter router, IUserSession session, IEventService events) { // this will check the authentication session and from it emit the check session // cookie needed from JS-based signout clients. await session.EnsureSessionIdCookieAsync(); try { var endpoint = router.Find(context); if (endpoint != null) { _logger.LogInformation("Invoking IdentityServer endpoint: {endpointType} for {url}", endpoint.GetType().FullName, context.Request.Path.ToString()); var result = await endpoint.ProcessAsync(context); if (result != null) { _logger.LogTrace("Invoking result: {type}", result.GetType().FullName); await result.ExecuteAsync(context); } return; } } catch (Exception ex) { await events.RaiseAsync(new UnhandledExceptionEvent(ex)); _logger.LogCritical(ex, "Unhandled exception: {exception}", ex.Message); throw; } await _next(context); }
/// <summary> /// Invokes the middleware. /// </summary> /// <param name="context">The context.</param> /// <param name="router">The router.</param> /// <param name="session">The user session.</param> /// <param name="events">The event service.</param> /// <param name="issuerNameService">The issuer name service</param> /// <param name="backChannelLogoutService"></param> /// <returns></returns> public async Task Invoke( HttpContext context, IEndpointRouter router, IUserSession session, IEventService events, IIssuerNameService issuerNameService, IBackChannelLogoutService backChannelLogoutService) { // this will check the authentication session and from it emit the check session // cookie needed from JS-based signout clients. await session.EnsureSessionIdCookieAsync(); context.Response.OnStarting(async() => { if (context.GetSignOutCalled()) { _logger.LogDebug("SignOutCalled set; processing post-signout session cleanup."); // this clears our session id cookie so JS clients can detect the user has signed out await session.RemoveSessionIdCookieAsync(); // back channel logout var logoutContext = await session.GetLogoutNotificationContext(); if (logoutContext != null) { await backChannelLogoutService.SendLogoutNotificationsAsync(logoutContext); } } }); try { var endpoint = router.Find(context); if (endpoint != null) { LicenseValidator.ValidateIssuer(await issuerNameService.GetCurrentAsync()); _logger.LogInformation("Invoking IdentityServer endpoint: {endpointType} for {url}", endpoint.GetType().FullName, context.Request.Path.ToString()); var result = await endpoint.ProcessAsync(context); if (result != null) { _logger.LogTrace("Invoking result: {type}", result.GetType().FullName); await result.ExecuteAsync(context); } return; } } catch (Exception ex) { await events.RaiseAsync(new UnhandledExceptionEvent(ex)); _logger.LogCritical(ex, "Unhandled exception: {exception}", ex.Message); throw; } await _next(context); }
public async Task Invoke(HttpContext context, IEndpointRouter router /*, IUserSession session, IEventService events*/) { try { IEndpointHandler endpoint = router.Find(context); if (endpoint != null) { _logger.LogInformation("Invoking IdentityServer endpoint: {endpointType} for {url}", endpoint.GetType().FullName, context.Request.Path.ToString()); IEndpointResult result = await endpoint.ProcessAsync(context); if (result != null) { _logger.LogTrace("Invoking result: {type}", result.GetType().FullName); await result.ExecuteAsync(context); } return; } } catch (Exception ex) { //await events.RaiseAsync(new UnhandledExceptionEvent(ex)); _logger.LogCritical(ex, "Unhandled exception: {exception}", ex.Message); throw; } await _next(context); }
public async Task InvokeAsync() { ActionResult result = null; bool executed = false; try { _logger.LogInformation("C# HTTP trigger Authority function processed a request."); var context = _httpContextAccessor.HttpContext; var endpointHandler = _endpointRouter.Find(_httpContextAccessor.HttpContext); if (endpointHandler != null) { _logger.LogInformation("Invoking IdentityServer endpoint: {endpointType} for {url}", endpointHandler.GetType().FullName, context.Request.Path.ToString()); _logger.LogInformation( $"Found IdentityServer endpoint {_httpContextAccessor.HttpContext.Request.Path}."); var endpointResult = await endpointHandler.ProcessAsync(_httpContextAccessor.HttpContext); var endpointResult2 = endpointResult as IEndpointResult2; if (endpointResult2 != null) { /* * More effective if we get the object value directly from the endpointResult. * Need to ask IdentityServer to expose that inner value. * I did it temporarily by modifying the IdentityServer4 code by added the IEndpointResult2 * interface to the endpoint results. */ _logger.LogTrace("Invoking result: {type}", endpointResult2.GetType().FullName); await endpointResult2.ExecuteAsync(_httpContextAccessor.HttpResponseMessage); executed = true; } /* * var json = ""; * * await endpointResult.ExecuteAsync(_httpContextAccessor.HttpContext); * * _httpContextAccessor.HttpContext.Response.Body.Seek(0, SeekOrigin.Begin); * StreamReader rdr = new StreamReader(_httpContextAccessor.HttpContext.Response.Body, Encoding.UTF8); * json = rdr.ReadToEnd(); */ } } catch (Exception ex) { await _events.RaiseAsync(new UnhandledExceptionEvent(ex)); _logger.LogCritical(ex, "Unhandled exception: {exception}", ex.Message); throw; } if (!executed) { _httpContextAccessor.HttpResponseMessage.StatusCode = HttpStatusCode.NotFound; } }
public async Task Invoke(HttpContext context, IEndpointRouter router, IdentityServerContext idSvrContext) { var endpoint = router.Find(context); if (endpoint != null) { var result = await endpoint.ProcessAsync(idSvrContext); if (result != null) { await result.ExecuteAsync(idSvrContext); } return; } await _next(context); }
public async Task Invoke( HttpContext context, IEndpointRouter router) { try { var endpoint = router.Find(context); if (endpoint != null) { _logger.LogInformation("Invoking IdentityServer endpoint: {endpointType} for {url}", endpoint.GetType().FullName, context.Request.Path.ToString()); var result = await endpoint.ProcessAsync(context); if (result != null) { _logger.LogTrace("Invoking result: {type}", result.GetType().FullName); var state = new ResponseState { EndpointResult = result, HttpContext = context, CookieItems = new Dictionary <string, string>() }; state.CookieItems["herb"] = "stahl"; context.Response.OnStarting(OnStartingCallBack, state); } return; } } catch (Exception ex) { _logger.LogCritical(ex, "Unhandled exception: {exception}", ex.Message); throw; } await _next(context); }
/// <summary> /// Invokes the middleware. /// </summary> /// <param name="context">The context.</param> /// <param name="router">The router.</param> /// <param name="userSession">The user session.</param> /// <param name="events">The event service.</param> /// <param name="issuerNameService">The issuer name service</param> /// <param name="sessionCoordinationService"></param> /// <returns></returns> public async Task Invoke( HttpContext context, IEndpointRouter router, IUserSession userSession, IEventService events, IIssuerNameService issuerNameService, ISessionCoordinationService sessionCoordinationService) { // this will check the authentication session and from it emit the check session // cookie needed from JS-based signout clients. await userSession.EnsureSessionIdCookieAsync(); context.Response.OnStarting(async() => { if (context.GetSignOutCalled()) { _logger.LogDebug("SignOutCalled set; processing post-signout session cleanup."); // this clears our session id cookie so JS clients can detect the user has signed out await userSession.RemoveSessionIdCookieAsync(); var user = await userSession.GetUserAsync(); if (user != null) { var session = new UserSession { SubjectId = user.GetSubjectId(), SessionId = await userSession.GetSessionIdAsync(), DisplayName = user.GetDisplayName(), ClientIds = (await userSession.GetClientListAsync()).ToList(), Issuer = await issuerNameService.GetCurrentAsync() }; await sessionCoordinationService.ProcessLogoutAsync(session); } } }); try { var endpoint = router.Find(context); if (endpoint != null) { var endpointType = endpoint.GetType().FullName; using var activity = Tracing.BasicActivitySource.StartActivity("IdentityServerProtocolRequest"); activity?.SetTag(Tracing.Properties.EndpointType, endpointType); LicenseValidator.ValidateIssuer(await issuerNameService.GetCurrentAsync()); _logger.LogInformation("Invoking IdentityServer endpoint: {endpointType} for {url}", endpointType, context.Request.Path.ToString()); var result = await endpoint.ProcessAsync(context); if (result != null) { _logger.LogTrace("Invoking result: {type}", result.GetType().FullName); await result.ExecuteAsync(context); } return; } } catch (Exception ex) { await events.RaiseAsync(new UnhandledExceptionEvent(ex)); _logger.LogCritical(ex, "Unhandled exception: {exception}", ex.Message); throw; } await _next(context); }