public void DealWithException(RequestProcessingContext context, Exception exception) { var response = CreateResponse(context); response.Exception = new ExceptionInfo(exception); SetExceptionType(response, exception); context.MarkAsProcessed(response); }
public void DealWithPreviouslyOccurredExceptions(RequestProcessingContext context) { var response = CreateResponse(context); response.Exception = new ExceptionInfo(new Exception(ExceptionType.EarlierRequestAlreadyFailed.ToString())); response.ExceptionType = ExceptionType.EarlierRequestAlreadyFailed; context.MarkAsProcessed(response); }
/// <summary> /// Executes after the handling request. /// </summary> /// <param name="context"> /// The context. /// </param> public void AfterHandlingRequest( RequestProcessingContext context ) { if (context!= null && context.Response != null) { try { if ( context.Response.Exception == null ) { if ( _validationFailures.Count > 0 ) { if ( context.Response is IDtoResponse ) { var dto = ( context.Response as IDtoResponse ).GetDto (); MapFailures ( _validationFailures, dto ); } else { Logger.Error ( "Validation failed but no failures mapped to data transfer object, because the response type ({0}) is not derived from {1}", context.Response.GetType ().Name, typeof( IDtoResponse ).Name ); } } } } catch ( Exception e ) { var response = context.Response; response.Exception = new ExceptionInfo ( e ); response.ExceptionType = ExceptionType.Unknown; } } }
private Type TryBasedOnCachedResponse(RequestProcessingContext context) { var cacheManager = IoC.Container.Resolve<ICacheManager>(); if(cacheManager.IsCachingEnabledFor(context.Request.GetType())) { var response = cacheManager.GetCachedResponseFor(context.Request); if (response != null) return response.GetType(); } return null; }
private Type TryBasedOnRequestHandler(RequestProcessingContext context) { try { var handler = (IRequestHandler)IoC.Container.Resolve(GetRequestHandlerTypeFor(context.Request)); return handler.CreateDefaultResponse().GetType(); } catch { return null; } }
/// <summary> /// Befores the handling request. /// </summary> /// <param name="context">The context.</param> public void BeforeHandlingRequest(RequestProcessingContext context) { if (context != null && context.Request != null) { var request = context.Request; var resource = new ResourceRequest { request.GetType ().FullName }; if ( !_accessControlManager.CanAccess ( resource ) ) { throw new InvalidOperationException ( "You do not have permission to access: " + resource ); } } }
public override void BeforeHandlingRequest(RequestProcessingContext context) { try { Validate.Object(context.Request as dynamic); } catch (ValidationException exc) { var response = CreateDefaultResponseFor(context.Request); response.Exception = new ExceptionInfo(exc); response.ExceptionType = ExceptionType.Unknown; context.MarkAsProcessed(response); } }
private Type DetermineResponseType(RequestProcessingContext context) { var strategies = new Func<RequestProcessingContext, Type>[] { TryBasedOnConventions, TryBasedOnCachedResponse, TryBasedOnRequestHandler }; foreach (var strategy in strategies) { var responseType = strategy(context); if (responseType != null) return responseType; } return typeof(Response); }
private Response CreateResponse(RequestProcessingContext context) { var responseType = DetermineResponseType(context); return (Response)Activator.CreateInstance(responseType); }
private Type TryBasedOnRequestHandler(RequestProcessingContext context) { IRequestHandler handler = null; try { handler = (IRequestHandler)IoC.Container.Resolve(GetRequestHandlerTypeFor(context.Request)); return handler.CreateDefaultResponse().GetType(); } catch { return null; } finally { if (handler != null) { IoC.Container.Release(handler); } } }
private Type TryBasedOnConventions(RequestProcessingContext context) { var conventions = IoC.Container.TryResolve<IConventions>(); if (conventions != null) return conventions.GetResponseTypeFor(context.Request); return null; }
private void HandleRequest(RequestProcessingContext requestProcessingState) { var request = requestProcessingState.Request; if (request is OneWayRequest) { using (var handler = (IOneWayRequestHandler)IoC.Container.Resolve(GetOneWayRequestHandlerTypeFor(request))) { try { ExecuteHandler((OneWayRequest)request, handler); } finally { IoC.Container.Release(handler); } } } else { using (var handler = (IRequestHandler)IoC.Container.Resolve(GetRequestHandlerTypeFor(request))) { try { var response = GetResponseFromHandler(request, handler); requestProcessingState.MarkAsProcessed(response); } finally { IoC.Container.Release(handler); } } } }
private void DispatchRequestsToHandlers(List<Response> responses, params Request[] requests) { bool exceptionsPreviouslyOccurred = false; foreach (var request in requests) { var requestProcessingState = new RequestProcessingContext(request); IList<IRequestHandlerInterceptor> interceptors = new List<IRequestHandlerInterceptor>(); try { IList<IRequestHandlerInterceptor> invokedInterceptors = new List<IRequestHandlerInterceptor>(); if (!exceptionsPreviouslyOccurred) { interceptors = ResolveInterceptors(); foreach (var interceptor in interceptors) { interceptor.BeforeHandlingRequest(requestProcessingState); invokedInterceptors.Add(interceptor); if (requestProcessingState.IsProcessed) { responses.Add(requestProcessingState.Response); break; } } } if (!requestProcessingState.IsProcessed) { var skipHandler = false; var cachingIsEnabledForThisRequest = _cacheManager.IsCachingEnabledFor(request.GetType()); if (cachingIsEnabledForThisRequest) { var cachedResponse = _cacheManager.GetCachedResponseFor(request); if (cachedResponse != null) { if (exceptionsPreviouslyOccurred) { var dummyResponse = Activator.CreateInstance(cachedResponse.GetType()) as Response; responses.Add(SetStandardExceptionInfoWhenEarlierRequestsFailed(dummyResponse)); requestProcessingState.MarkAsProcessed(dummyResponse); } else { responses.Add(cachedResponse); requestProcessingState.MarkAsProcessed(cachedResponse); } skipHandler = true; } } if (!skipHandler) { BeforeResolvingRequestHandler(request); using (var handler = (IRequestHandler)IoC.Container.Resolve(GetRequestHandlerTypeFor(request))) { try { if (!exceptionsPreviouslyOccurred) { var response = GetResponseFromHandler(request, handler); exceptionsPreviouslyOccurred = response.ExceptionType != ExceptionType.None; responses.Add(response); requestProcessingState.MarkAsProcessed(response); if (response.ExceptionType == ExceptionType.None && cachingIsEnabledForThisRequest) { _cacheManager.StoreInCache(request, response); } } else { var response = handler.CreateDefaultResponse(); responses.Add(SetStandardExceptionInfoWhenEarlierRequestsFailed(response)); requestProcessingState.MarkAsProcessed(response); } } finally { IoC.Container.Release(handler); } } } } foreach (var interceptor in invokedInterceptors.Reverse()) { interceptor.AfterHandlingRequest(requestProcessingState); } invokedInterceptors.Clear(); } finally { SaveDisposeInterceptors(interceptors); } } }
private IEnumerable<Exception> RunInvokedInterceptorsSafely(RequestProcessingContext requestProcessingState, IList<IRequestHandlerInterceptor> invokedInterceptors) { var exceptionsFromInterceptor = new List<Exception>(); foreach (var interceptor in invokedInterceptors.Reverse()) { try { interceptor.AfterHandlingRequest(requestProcessingState); } catch (Exception exc) { exceptionsFromInterceptor.Add(exc); } } return exceptionsFromInterceptor; }
private void InvokeRequestHandler(RequestProcessingContext requestProcessingState) { var request = requestProcessingState.Request; BeforeResolvingRequestHandler(request); using (var handler = (IRequestHandler)IoC.Container.Resolve(GetRequestHandlerTypeFor(request))) { try { var response = GetResponseFromHandler(request, handler); requestProcessingState.MarkAsProcessed(response); } finally { IoC.Container.Release(handler); } } }
private void InvokeRequestHandler(RequestProcessingContext requestProcessingState) { BeforeResolvingRequestHandler(requestProcessingState.Request); HandleRequest(requestProcessingState); }
/// <summary> /// Executes before the handling request. /// </summary> /// <param name="context"> /// The context. /// </param> public void BeforeHandlingRequest( RequestProcessingContext context ) { DomainEvent.Register<RuleViolationEvent> ( failure => _validationFailures.AddRange ( failure.RuleViolations ) ); }
public override void AfterHandlingRequest(RequestProcessingContext context) { }
protected override void Given() { IoC.Container = new Container(); errorHandler = new RequestProcessingErrorHandler(new ServiceLayerConfiguration(IoC.Container)); request = new RequestA(); Context = new RequestProcessingContext(request); cacheManager = Stubbed<ICacheManager>(); Container.RegisterInstance(cacheManager); EstablishContext(); }
private async Task InvokeRequestHandlerAsync(RequestProcessingContext requestProcessingState) { BeforeResolvingRequestHandler(requestProcessingState.Request); await HandleRequestAsync(requestProcessingState); }