/// <summary> /// HTTP content missing Content-Type. /// </summary> public static ServiceErrorDto CreateMissingContentType() => ServiceErrors.CreateInvalidRequest("HTTP content missing Content-Type.");
/// <summary> /// HTTP content has unsupported Content-Type. /// </summary> public static ServiceErrorDto CreateUnsupportedContentType(string contentType) => ServiceErrors.CreateInvalidRequest($"HTTP content has unsupported Content-Type: {contentType}");
private async Task HostAsync(HttpContext httpContext) { var httpRequest = httpContext.Request; var requestUrl = httpRequest.GetEncodedUrl(); var apiHandler = new ConformanceApiHttpHandler(new ConformanceApiService(m_tests)); var requestMessage = new HttpRequestMessage(new HttpMethod(httpRequest.Method), requestUrl) { Content = new StreamContent(httpRequest.Body), }; foreach (var header in httpRequest.Headers) { // Every header should be able to fit into one of the two header collections. // Try message.Headers first since that accepts more of them. if (!requestMessage.Headers.TryAddWithoutValidation(header.Key, header.Value.AsEnumerable())) { requestMessage.Content.Headers.TryAddWithoutValidation(header.Key, header.Value.AsEnumerable()); } } HttpResponseMessage?responseMessage = null; ServiceErrorDto? error = null; try { responseMessage = await apiHandler.TryHandleHttpRequestAsync(requestMessage, httpContext.RequestAborted).ConfigureAwait(false); if (responseMessage == null) { error = ServiceErrors.CreateInvalidRequest($"Test not found for {httpRequest.Method} {requestUrl}"); } } catch (Exception exception) { error = ServiceErrorUtility.CreateInternalErrorForException(exception); } if (error != null) { var statusCode = HttpServiceErrors.TryGetHttpStatusCode(error.Code) ?? HttpStatusCode.InternalServerError; responseMessage = new HttpResponseMessage(statusCode) { Content = JsonHttpContentSerializer.Instance.CreateHttpContent(error) }; } if (responseMessage != null) { using (responseMessage) { var response = httpContext.Response; response.StatusCode = (int)responseMessage.StatusCode; var responseHeaders = responseMessage.Headers; // Ignore the Transfer-Encoding header if it is just "chunked". // We let the host decide about whether the response should be chunked or not. if (responseHeaders.TransferEncodingChunked == true && responseHeaders.TransferEncoding.Count == 1) { responseHeaders.TransferEncoding.Clear(); } foreach (var header in responseHeaders) { response.Headers.Append(header.Key, header.Value.ToArray()); } // ReSharper disable once ConditionIsAlwaysTrueOrFalse if (responseMessage.Content != null) { var contentHeaders = responseMessage.Content.Headers; // Copy the response content headers only after ensuring they are complete. // We ask for Content-Length first because HttpContent lazily computes this // and only afterwards writes the value into the content headers. _ = contentHeaders.ContentLength; foreach (var header in contentHeaders) { response.Headers.Append(header.Key, header.Value.ToArray()); } await responseMessage.Content.CopyToAsync(response.Body).ConfigureAwait(false); } } } }
/// <summary> /// Sends an HTTP request and processes the response. /// </summary> protected async Task <ServiceResult <TResponse> > TrySendRequestAsync <TRequest, TResponse>(HttpMethodMapping <TRequest, TResponse> mapping, TRequest request, CancellationToken cancellationToken) where TRequest : ServiceDto, new() where TResponse : ServiceDto, new() { if (request == null) { throw new ArgumentNullException(nameof(request)); } try { // validate the request DTO var requestValidation = mapping.ValidateRequest(request); if (requestValidation.IsFailure) { return(requestValidation.AsFailure()); } // create the HTTP request with the right method, path, query string, and headers var httpRequestResult = TryCreateHttpRequest(mapping.HttpMethod, mapping.Path, mapping.GetUriParameters(request), mapping.GetRequestHeaders(request)); if (httpRequestResult.IsFailure) { return(httpRequestResult.AsFailure()); } using (var httpRequest = httpRequestResult.Value) { // create the request body if necessary var requestBody = mapping.GetRequestBody(request); if (requestBody != null) { httpRequest.Content = ContentSerializer.CreateHttpContent(requestBody); } // send the HTTP request and get the HTTP response using (var httpResponse = await SendRequestAsync(httpRequest, request, cancellationToken).ConfigureAwait(false)) { // find the response mapping for the status code var statusCode = httpResponse.StatusCode; var responseMapping = mapping.ResponseMappings.FirstOrDefault(x => x.StatusCode == statusCode); // fail if no response mapping can be found for the status code if (responseMapping == null) { return(ServiceResult.Failure(await CreateErrorFromHttpResponseAsync(httpResponse, cancellationToken).ConfigureAwait(false))); } // read the response body if necessary object responseBody = null; if (responseMapping.ResponseBodyType != null) { ServiceResult <object> responseResult = await ContentSerializer.ReadHttpContentAsync( responseMapping.ResponseBodyType, httpResponse.Content, cancellationToken).ConfigureAwait(false); if (responseResult.IsFailure) { var error = responseResult.Error; error.Code = ServiceErrors.InvalidResponse; return(ServiceResult.Failure(error)); } responseBody = responseResult.Value; } // create the response DTO var response = responseMapping.CreateResponse(responseBody); response = mapping.SetResponseHeaders(response, HttpServiceUtility.CreateDictionaryFromHeaders(httpResponse.Headers)); return(ServiceResult.Success(response)); } } } catch (OperationCanceledException) when(!cancellationToken.IsCancellationRequested) { // HttpClient timeout return(ServiceResult.Failure(ServiceErrors.CreateTimeout())); } catch (Exception exception) when(exception is ArgumentException || exception is HttpRequestException || exception is IOException) { // cancellation can cause the wrong exception cancellationToken.ThrowIfCancellationRequested(); // error contacting service return(ServiceResult.Failure(CreateErrorFromException(exception))); } }
/// <summary> /// Attempts to handle a service method. /// </summary> protected async Task <HttpResponseMessage?> TryHandleServiceMethodAsync <TRequest, TResponse>(HttpMethodMapping <TRequest, TResponse> mapping, HttpRequestMessage httpRequest, Func <TRequest, CancellationToken, Task <ServiceResult <TResponse> > > invokeMethodAsync, CancellationToken cancellationToken) where TRequest : ServiceDto, new() where TResponse : ServiceDto, new() { if (mapping == null) { throw new ArgumentNullException(nameof(mapping)); } if (httpRequest == null) { throw new ArgumentNullException(nameof(httpRequest)); } if (invokeMethodAsync == null) { throw new ArgumentNullException(nameof(invokeMethodAsync)); } if (httpRequest.RequestUri == null) { throw new ArgumentException("RequestUri must be specified.", nameof(httpRequest)); } if (httpRequest.Method != mapping.HttpMethod) { return(null); } var pathParameters = TryMatchHttpRoute(httpRequest.RequestUri, m_rootPath + mapping.Path); if (pathParameters == null) { return(null); } var context = new ServiceHttpContext(); ServiceHttpContext.SetContext(httpRequest, context); var aspectHttpResponse = await AdaptTask(RequestReceivedAsync(httpRequest, cancellationToken)).ConfigureAwait(true); if (aspectHttpResponse != null) { return(aspectHttpResponse); } ServiceErrorDto?error = null; object?requestBody = null; if (mapping.RequestBodyType != null) { try { var serializer = GetHttpContentSerializer(mapping.RequestBodyType); var requestResult = await AdaptTask(serializer.ReadHttpContentAsync(mapping.RequestBodyType, httpRequest.Content, cancellationToken)).ConfigureAwait(true); if (requestResult.IsFailure) { error = requestResult.Error; } else { requestBody = requestResult.Value; } } catch (Exception exception) when(ShouldCreateErrorFromException(exception)) { // cancellation can cause the wrong exception cancellationToken.ThrowIfCancellationRequested(); // error reading request body error = CreateErrorFromException(exception); } } TResponse?response = null; if (error == null) { var request = mapping.CreateRequest(requestBody); var uriParameters = new Dictionary <string, string?>(StringComparer.OrdinalIgnoreCase); foreach (var queryParameter in ParseQueryString(httpRequest.RequestUri.Query)) { uriParameters[queryParameter.Key] = queryParameter.Value[0]; } foreach (var pathParameter in pathParameters) { uriParameters[pathParameter.Key] = pathParameter.Value; } request = mapping.SetUriParameters(request, uriParameters); request = mapping.SetRequestHeaders(request, HttpServiceUtility.CreateDictionaryFromHeaders(httpRequest.Headers, httpRequest.Content?.Headers) !); context.Request = request; if (!m_skipRequestValidation && !request.Validate(out var requestErrorMessage)) { error = ServiceErrors.CreateInvalidRequest(requestErrorMessage); } else { var methodResult = await invokeMethodAsync(request, cancellationToken).ConfigureAwait(true); if (methodResult.IsFailure) { error = methodResult.Error; } else { response = methodResult.Value; if (!m_skipResponseValidation && !response.Validate(out var responseErrorMessage)) { error = ServiceErrors.CreateInvalidResponse(responseErrorMessage); response = null; } } } context.Result = error != null?ServiceResult.Failure(error) : ServiceResult.Success <ServiceDto>(response !); } HttpResponseMessage httpResponse; if (error == null) { var responseMappingGroups = mapping.ResponseMappings .GroupBy(x => x.MatchesResponse(response !)) .Where(x => x.Key != false) .OrderByDescending(x => x.Key) .ToList(); if (responseMappingGroups.Count >= 1 && responseMappingGroups[0].Count() == 1) { var responseMapping = responseMappingGroups[0].Single(); httpResponse = new HttpResponseMessage(responseMapping.StatusCode); var responseHeaders = mapping.GetResponseHeaders(response !); var headersResult = HttpServiceUtility.TryAddNonContentHeaders(httpResponse.Headers, responseHeaders); if (headersResult.IsFailure) { throw new InvalidOperationException(headersResult.Error !.Message); } if (responseMapping.ResponseBodyType != null) { var serializer = GetHttpContentSerializer(responseMapping.ResponseBodyType); var mediaType = responseMapping.ResponseBodyContentType ?? responseHeaders?.GetContentType() ?? GetAcceptedMediaType(httpRequest, serializer); httpResponse.Content = serializer.CreateHttpContent(responseMapping.GetResponseBody(response !) !, mediaType); } } else { throw new InvalidOperationException($"Found {responseMappingGroups.Sum(x => x.Count())} valid HTTP responses for {typeof(TResponse).Name}: {response}"); } } else { var statusCode = error.Code == null ? HttpStatusCode.InternalServerError : (TryGetCustomHttpStatusCode(error.Code) ?? HttpServiceErrors.TryGetHttpStatusCode(error.Code) ?? HttpStatusCode.InternalServerError); httpResponse = new HttpResponseMessage(statusCode); if (statusCode != HttpStatusCode.NoContent && statusCode != HttpStatusCode.NotModified) { var mediaType = GetAcceptedMediaType(httpRequest, m_contentSerializer); httpResponse.Content = m_contentSerializer.CreateHttpContent(error, mediaType); } } httpResponse.RequestMessage = httpRequest; await AdaptTask(ResponseReadyAsync(httpResponse, cancellationToken)).ConfigureAwait(true); return(httpResponse); }
public async Task TimeoutThrown() { await GetApiInfoInvalidResponse( _ => throw new OperationCanceledException(), ServiceErrors.Timeout, ServiceErrors.CreateTimeout().Message); }
/// <summary> /// Called to create an error object from an unexpected exception. /// </summary> protected virtual ServiceErrorDto CreateErrorFromException(Exception exception) => ServiceErrors.CreateInvalidRequest("Unexpected error while reading request body.");
public async Task <ServiceResult <GenerateResponseDto> > GenerateAsync(GenerateRequestDto request, CancellationToken cancellationToken) { if (request == null) { throw new ArgumentNullException(nameof(request)); } try { var input = new ServiceDefinitionText(request.Definition?.Name ?? "", request.Definition?.Text ?? ""); var isSwagger = input.Text.StartsWith("{", StringComparison.Ordinal) || input.Text.StartsWith("swagger:", StringComparison.Ordinal); var service = isSwagger ? new SwaggerParser().ParseDefinition(input) : new FsdParser().ParseDefinition(input); var generatorName = request.Generator?.Name; switch (generatorName) { case "csharp": return(ServiceResult.Success(GenerateCode(() => new CSharpGenerator(), g => g.GenerateOutput(service)))); case "javascript": return(ServiceResult.Success(GenerateCode(() => new JavaScriptGenerator(), g => g.GenerateOutput(service)))); case "typescript": return(ServiceResult.Success(GenerateCode(() => new JavaScriptGenerator { TypeScript = true }, g => g.GenerateOutput(service)))); case "markdown": return(ServiceResult.Success(GenerateCode(() => new MarkdownGenerator(), g => g.GenerateOutput(service)))); case "fsd": return(ServiceResult.Success(GenerateCode(() => new FsdGenerator(), g => g.GenerateOutput(service)))); case "swagger-json": return(ServiceResult.Success(GenerateCode(() => new SwaggerGenerator { GeneratesJson = true }, g => g.GenerateOutput(service)))); case "swagger-yaml": return(ServiceResult.Success(GenerateCode(() => new SwaggerGenerator(), g => g.GenerateOutput(service)))); case "asp-net-web-api": return(ServiceResult.Success(GenerateCode(() => new AspNetGenerator(), g => g.GenerateOutput(service)))); case "crash": throw new InvalidOperationException("Intentional exception for diagnostic purposes."); default: return(ServiceResult.Failure(ServiceErrors.CreateInvalidRequest($"Unrecognized generator '{generatorName}'."))); } } catch (ServiceDefinitionException exception) { var error = exception.Errors[0]; return(ServiceResult.Success(new GenerateResponseDto { Failure = new FailureDto { Message = error.Message, Line = error.Position?.LineNumber, Column = error.Position?.ColumnNumber, }, })); } }
public static ServiceErrorDto CreateInvalidRequestMissingWidgetIds() { return(ServiceErrors.CreateInvalidRequest("Must specify at least one widget ID.")); }
public static ServiceErrorDto CreateNotFoundWidget(string id) { return(ServiceErrors.CreateNotFound($"The widget with ID '{id}' was not found.")); }
public static ServiceErrorDto CreateInvalidRequestMissingWidgetId() { return(ServiceErrors.CreateInvalidRequest("The widget ID is missing.")); }