public virtual object HandleException(IRequest request, TRequest requestDto, Exception ex) { var errorResponse = HostContext.RaiseServiceException(request, requestDto, ex) ?? DtoUtils.CreateErrorResponse(requestDto, ex); AfterEachRequest(request, requestDto, errorResponse ?? ex); return(errorResponse); }
public virtual async Task <object> HandleExceptionAsync(IRequest request, TRequest requestDto, Exception ex, object service) { var errorResponse = (service is IServiceErrorFilter filter ? await filter.OnExceptionAsync(requestDto, ex) : null) ?? await HandleExceptionAsync(request, requestDto, ex) ?? await HostContext.RaiseServiceException(request, requestDto, ex) ?? DtoUtils.CreateErrorResponse(requestDto, ex); AfterEachRequest(request, requestDto, errorResponse ?? ex, service); return(errorResponse); }
private static async Task RequestFilterAsync(IRequest req, IResponse res, object requestDto, bool treatInfoAndWarningsAsErrors) { var validator = ValidatorCache.GetValidator(req, requestDto.GetType()); if (validator == null) { return; } try { var validationResult = await Validate(validator, req, requestDto); if (treatInfoAndWarningsAsErrors && validationResult.IsValid) { return; } if (!treatInfoAndWarningsAsErrors && (validationResult.IsValid || validationResult.Errors.All(v => v.Severity != Severity.Error))) { return; } var errorResponse = await HostContext.RaiseServiceException(req, requestDto, validationResult.ToException()) ?? DtoUtils.CreateErrorResponse(requestDto, validationResult.ToErrorResult()); var validationFeature = HostContext.GetPlugin <ValidationFeature>(); if (validationFeature?.ErrorResponseFilter != null) { errorResponse = validationFeature.ErrorResponseFilter(validationResult, errorResponse); } await res.WriteToResponse(req, errorResponse); } catch (Exception ex) { var validationEx = ex.UnwrapIfSingleException(); var errorResponse = await HostContext.RaiseServiceException(req, requestDto, validationEx) ?? DtoUtils.CreateErrorResponse(requestDto, validationEx); await res.WriteToResponse(req, errorResponse); } finally { using (validator as IDisposable) { } } }
public static Task RequestFilterAsync(IRequest req, IResponse res, object requestDto) { var validator = ValidatorCache.GetValidator(req, requestDto.GetType()); var ruleSet = req.Verb; if (validator == null || !validator.HasAsyncValidators(ruleSet)) { return(TypeConstants.EmptyTask); } var validateTask = validator.ValidateAsync( new ValidationContext(requestDto, null, new MultiRuleSetValidatorSelector(ruleSet)) { Request = req }); return(HostContext.Async.ContinueWith(req, validateTask, t => { if (t.IsFaulted) { var validationEx = t.Exception.UnwrapIfSingleException(); var errorResponse = HostContext.RaiseServiceException(req, requestDto, validationEx) ?? DtoUtils.CreateErrorResponse(requestDto, validationEx); return res.WriteToResponse(req, errorResponse); } else { var validationResult = t.Result; if (validationResult.IsValid) { return TypeConstants.TrueTask; } var errorResponse = HostContext.RaiseServiceException(req, requestDto, validationResult.ToException()) ?? DtoUtils.CreateErrorResponse(requestDto, validationResult.ToErrorResult()); var validationFeature = HostContext.GetPlugin <ValidationFeature>(); if (validationFeature?.ErrorResponseFilter != null) { errorResponse = validationFeature.ErrorResponseFilter(validationResult, errorResponse); } return res.WriteToResponse(req, errorResponse); } }) .ContinueWith(t => { using (validator as IDisposable) { } })); }
protected async Task <object> ManagedHandleExceptionAsync(IRequest req, TRequest requestDto, Exception ex, object service) { try { return(await HandleExceptionAsync(req, requestDto, ex, service).ConfigAwait()); } catch (Exception e) { Log.Error($"Invalid State: ServiceRunner HandleExceptionAsync() should handle the Exception and return an Error Response, not throw Exceptions", e); var errorResponse = (service is IServiceErrorFilter filter ? await filter.OnExceptionAsync(requestDto, ex).ConfigAwait() : null) ?? await HostContext.RaiseServiceException(req, requestDto, ex).ConfigAwait() ?? DtoUtils.CreateErrorResponse(requestDto, ex); AfterEachRequest(req, requestDto, errorResponse ?? ex, service); return(errorResponse); } }
public static void RequestFilter(IRequest req, IResponse res, object requestDto) { var validator = ValidatorCache.GetValidator(req, requestDto.GetType()); if (validator == null) { return; } try { var validatorWithHttpRequest = validator as IRequiresRequest; if (validatorWithHttpRequest != null) { validatorWithHttpRequest.Request = req; } var ruleSet = req.Verb; var validationResult = validator.Validate( new ValidationContext(requestDto, null, new MultiRuleSetValidatorSelector(ruleSet))); if (validationResult.IsValid) { return; } var errorResponse = HostContext.RaiseServiceException(req, requestDto, validationResult.ToException()) ?? DtoUtils.CreateErrorResponse(requestDto, validationResult.ToErrorResult()); var validationFeature = HostContext.GetPlugin <ValidationFeature>(); if (validationFeature != null && validationFeature.ErrorResponseFilter != null) { errorResponse = validationFeature.ErrorResponseFilter(validationResult, errorResponse); } res.WriteToResponse(req, errorResponse); } finally { using (validator as IDisposable) {} } }
protected Message ExecuteMessage(Message message, RequestAttributes requestAttributes, IRequest httpReq, IResponse httpRes) { var soapFeature = requestAttributes.ToSoapFeature(); appHost.AssertFeatures(soapFeature); if (httpReq == null) { httpReq = HostContext.GetCurrentRequest(); } if (httpRes == null && httpReq != null) { httpRes = httpReq.Response; } if (httpReq == null) { throw new ArgumentNullException(nameof(httpReq)); } if (httpRes == null) { throw new ArgumentNullException(nameof(httpRes)); } httpReq.UseBufferedStream = true; var requestMsg = message ?? GetRequestMessageFromStream(httpReq.InputStream); var soapAction = httpReq.GetHeader(HttpHeaders.SOAPAction) ?? GetAction(requestMsg); if (soapAction != null) { httpReq.OperationName = soapAction.Trim('"'); } if (HostContext.ApplyCustomHandlerRequestFilters(httpReq, httpRes)) { return(PrepareEmptyResponse(message, httpReq)); } string requestXml = GetRequestXml(requestMsg); var requestType = GetRequestType(requestMsg, requestXml); httpReq.OperationName = requestType.GetOperationName(); if (!HostContext.Metadata.CanAccess(requestAttributes, soapFeature.ToFormat(), requestType.GetOperationName())) { throw HostContext.UnauthorizedAccess(requestAttributes); } try { var useXmlSerializerRequest = requestType.HasAttribute <XmlSerializerFormatAttribute>(); var request = appHost.ApplyRequestConvertersAsync(httpReq, useXmlSerializerRequest ? XmlSerializableSerializer.Instance.DeserializeFromString(requestXml, requestType) : Serialization.DataContractSerializer.Instance.DeserializeFromString(requestXml, requestType) ).Result; httpReq.Dto = request; if (request is IRequiresSoapMessage requiresSoapMessage) { requiresSoapMessage.Message = requestMsg; } httpReq.SetItem(Keywords.SoapMessage, requestMsg); httpRes.ContentType = GetSoapContentType(httpReq.ContentType); var hasRequestFilters = HostContext.AppHost.GlobalRequestFiltersArray.Length > 0 || HostContext.AppHost.GlobalRequestFiltersAsyncArray.Length > 0 || FilterAttributeCache.GetRequestFilterAttributes(request.GetType()).Any(); if (hasRequestFilters) { HostContext.ApplyRequestFiltersAsync(httpReq, httpRes, request).Wait(); if (httpRes.IsClosed) { return(EmptyResponse(requestMsg, requestType)); } } httpReq.RequestAttributes |= requestAttributes; var response = ExecuteService(request, httpReq); if (response is Task taskResponse) { response = taskResponse.GetResult(); } response = appHost.ApplyResponseConvertersAsync(httpReq, response).Result; appHost.ApplyResponseFiltersAsync(httpReq, httpRes, response).Wait(); if (httpRes.IsClosed) { return(EmptyResponse(requestMsg, requestType)); } var httpResult = response as IHttpResult; if (httpResult != null) { response = httpResult.Response; } var noMsgAction = requestMsg.Headers.Action == null; var responseMsg = CreateResponseMessage(response, requestMsg.Version, requestType, noMsgAction); if (httpResult != null) { SetErrorStatusIfAny(httpReq.Response, responseMsg, httpResult.Status); } return(responseMsg); } catch (Exception ex) { if (httpReq.Dto != null) { HostContext.RaiseServiceException(httpReq, httpReq.Dto, ex).Wait(); } else { HostContext.RaiseUncaughtException(httpReq, httpRes, httpReq.OperationName, ex).Wait(); } throw new SerializationException("3) Error trying to deserialize requestType: " + requestType + ", xml body: " + requestXml, ex); } }
private static async Task RequestFilterAsync(IRequest req, IResponse res, object requestDto, bool treatInfoAndWarningsAsErrors) { var validator = ValidatorCache.GetValidator(req, requestDto.GetType()); if (validator == null) { return; } using (validator as IDisposable) { try { var validationResult = await validator.ValidateAsync(req, requestDto); if (treatInfoAndWarningsAsErrors && validationResult.IsValid) { return; } if (!treatInfoAndWarningsAsErrors && (validationResult.IsValid || validationResult.Errors.All(v => v.Severity != Severity.Error))) { return; } var errorResponse = await HostContext.RaiseServiceException(req, requestDto, validationResult.ToException()) ?? DtoUtils.CreateErrorResponse(requestDto, validationResult.ToErrorResult()); var autoBatchIndex = req.GetItem(Keywords.AutoBatchIndex)?.ToString(); if (autoBatchIndex != null) { var responseStatus = errorResponse.GetResponseStatus(); if (responseStatus != null) { if (responseStatus.Meta == null) { responseStatus.Meta = new Dictionary <string, string>(); } responseStatus.Meta[Keywords.AutoBatchIndex] = autoBatchIndex; } } var validationFeature = HostContext.GetPlugin <ValidationFeature>(); if (validationFeature?.ErrorResponseFilter != null) { errorResponse = validationFeature.ErrorResponseFilter(req, validationResult, errorResponse); } await res.WriteToResponse(req, errorResponse); } catch (Exception ex) { var validationEx = ex.UnwrapIfSingleException(); var errorResponse = await HostContext.RaiseServiceException(req, requestDto, validationEx) ?? DtoUtils.CreateErrorResponse(requestDto, validationEx); await res.WriteToResponse(req, errorResponse); } } }
private static async Task RequestFilterAsync(IRequest req, IResponse res, object requestDto, bool treatInfoAndWarningsAsErrors) { var requestType = requestDto.GetType(); await Validators.AssertTypeValidatorsAsync(req, requestDto, requestType); var validator = ValidatorCache.GetValidator(req, requestType); if (validator == null) { return; } using (validator as IDisposable) { if (validator is IHasTypeValidators hasTypeValidators && hasTypeValidators.TypeValidators.Count > 0) { foreach (var scriptValidator in hasTypeValidators.TypeValidators) { await scriptValidator.ThrowIfNotValidAsync(requestDto, req); } } try { if (req.Verb == HttpMethods.Patch) { // Ignore property rules for AutoCrud Patch operations with default values that aren't reset (which are ignored) if (validator is IServiceStackValidator ssValidator && requestDto is ICrud && requestType.IsOrHasGenericInterfaceTypeOf(typeof(IPatchDb <>))) { var typeProperties = TypeProperties.Get(requestType); var propsWithDefaultValues = new HashSet <string>(); var resetFields = GetResetFields(req.GetParam(Keywords.reset))?.ToSet(StringComparer.OrdinalIgnoreCase) ?? TypeConstants <string> .EmptyHashSet; foreach (var entry in typeProperties.PropertyMap) { if (entry.Value.PublicGetter == null || resetFields.Contains(entry.Key)) { continue; } var defaultValue = entry.Value.PropertyInfo.PropertyType.GetDefaultValue(); var propValue = entry.Value.PublicGetter(requestDto); if (propValue == null || propValue.Equals(defaultValue)) { propsWithDefaultValues.Add(entry.Key); } } if (propsWithDefaultValues.Count > 0) { ssValidator.RemovePropertyRules(rule => propsWithDefaultValues.Contains(rule.PropertyName)); } } } var validationResult = await validator.ValidateAsync(req, requestDto); if (treatInfoAndWarningsAsErrors && validationResult.IsValid) { return; } if (!treatInfoAndWarningsAsErrors && (validationResult.IsValid || validationResult.Errors.All(v => v.Severity != Severity.Error))) { return; } var errorResponse = await HostContext.RaiseServiceException(req, requestDto, validationResult.ToException()) ?? DtoUtils.CreateErrorResponse(requestDto, validationResult.ToErrorResult()); var autoBatchIndex = req.GetItem(Keywords.AutoBatchIndex)?.ToString(); if (autoBatchIndex != null) { var responseStatus = errorResponse.GetResponseStatus(); if (responseStatus != null) { if (responseStatus.Meta == null) { responseStatus.Meta = new Dictionary <string, string>(); } responseStatus.Meta[Keywords.AutoBatchIndex] = autoBatchIndex; } } var validationFeature = HostContext.GetPlugin <ValidationFeature>(); if (validationFeature?.ErrorResponseFilter != null) { errorResponse = validationFeature.ErrorResponseFilter(req, validationResult, errorResponse); } await res.WriteToResponse(req, errorResponse); } catch (Exception ex) { var validationEx = ex.UnwrapIfSingleException(); var errorResponse = await HostContext.RaiseServiceException(req, requestDto, validationEx) ?? DtoUtils.CreateErrorResponse(requestDto, validationEx); await res.WriteToResponse(req, errorResponse); } } }
public static async Task RequestFilterAsync(IRequest req, IResponse res, object requestDto) { var validator = ValidatorCache.GetValidator(req, requestDto.GetType()); var ruleSet = req.Verb; if (validator == null) { return; } try { ValidationResult validationResult; if (validator.HasAsyncValidators(ruleSet)) { validationResult = await validator.ValidateAsync( new ValidationContext(requestDto, null, new MultiRuleSetValidatorSelector(ruleSet)) { Request = req }); } else { validationResult = validator.Validate( new ValidationContext(requestDto, null, new MultiRuleSetValidatorSelector(ruleSet)) { Request = req }); } if (validationResult.IsValid) { return; } var errorResponse = await HostContext.RaiseServiceException(req, requestDto, validationResult.ToException()) ?? DtoUtils.CreateErrorResponse(requestDto, validationResult.ToErrorResult()); var validationFeature = HostContext.GetPlugin <ValidationFeature>(); if (validationFeature?.ErrorResponseFilter != null) { errorResponse = validationFeature.ErrorResponseFilter(validationResult, errorResponse); } await res.WriteToResponse(req, errorResponse); } catch (Exception ex) { var validationEx = ex.UnwrapIfSingleException(); var errorResponse = await HostContext.RaiseServiceException(req, requestDto, validationEx) ?? DtoUtils.CreateErrorResponse(requestDto, validationEx); await res.WriteToResponse(req, errorResponse); } finally { using (validator as IDisposable) { } } }