C# Request.CreateErrorResponse方法代码示例

        public override async Task<Response> ProcessRequest(Request request)
        {
            var fanoutRequest = request.HasInputBody ? await request.ReadInputBody<TieredRequest>() : null;
            if (request.HasInputBody && fanoutRequest == null)
            {
                // This indicates failed deserialization
                return request.CreateErrorResponse(HttpStatusCode.BadRequest, "Could not read input body");
            }

            // aggregation servers should fanout automagically. we honor filters for machine function and datacenter.
            if ((fanoutRequest == null || fanoutRequest.Sources == null || fanoutRequest.Sources.Count == 0) && this.server.EnableQueryAggregation)
            {
                if (fanoutRequest == null)
                {
                    fanoutRequest = new TieredRequest();
                }

                fanoutRequest.Sources = this.SelectSourceServers(request.QueryParameters).ToList();
            }

            var queryParameters = new DimensionSpecification(request.QueryParameters);
            var endOfName = request.Path.LastIndexOf('/');
            if (endOfName < 0)
            {
                return request.CreateErrorResponse(HttpStatusCode.BadRequest, "No command provided.");
            }

            var counterName = request.Path.Substring(0, endOfName);
            if (string.IsNullOrEmpty(counterName))
            {
                return request.CreateErrorResponse(HttpStatusCode.BadRequest, "No counter pattern provided.");
            }

            var commandName = request.Path.Substring(endOfName + 1);

            if (RestCommands.CounterInfoCommand.Equals(commandName, StringComparison.OrdinalIgnoreCase))
            {
                return await this.Info(request, fanoutRequest, counterName, queryParameters);
            }

            if (RestCommands.CounterQueryCommand.Equals(commandName, StringComparison.OrdinalIgnoreCase))
            {
                var response = await this.Query(counterName, fanoutRequest, queryParameters);
                return Response.Create(request, (HttpStatusCode)response.HttpResponseCode, response);
            }

            return request.CreateErrorResponse(HttpStatusCode.BadRequest, "Unknown command: " + commandName);
        }

        public override async Task<Response> ProcessRequest(Request request)
        {
            if (!request.HasInputBody)
            {
                return request.CreateErrorResponse(HttpStatusCode.BadRequest, "no input body provided.");
            }

            var registrationMessage = await request.ReadInputBody<ServerRegistration>();
            if (registrationMessage != null)
            {
                var server = this.serverList.InsertOrUpdate(registrationMessage);
                server.ProcessRegistrationMessage(registrationMessage);
                return new Response(request, HttpStatusCode.OK, "Registered.");
            }

            return request.CreateErrorResponse(HttpStatusCode.BadRequest, "Invalid data.");
        }

            public override Task<Response> ProcessRequest(Request request)
            {
                if (this.RequestReceived != null)
                {
                    return Task.FromResult(this.RequestReceived(request));
                }

                return Task.FromResult(request.CreateErrorResponse(HttpStatusCode.Gone, "Gone fishin'."));
            }

        public override Task<Response> ProcessRequest(Request request)
        {
            // The '.Servers' property actually returns a new list so this is totally reasonable.
            var response = new ListServerResponse {Servers = this.serverList.Servers};
            if (response.Servers.Count == 0)
            {
                return Task.FromResult(request.CreateErrorResponse(HttpStatusCode.NotFound, "No known servers."));
            }

            return Task.FromResult(Response.Create(request, HttpStatusCode.OK, response));
        }

        public override async Task<Response> ProcessRequest(Request request)
        {
            if (!request.HasInputBody)
            {
                return request.CreateErrorResponse(HttpStatusCode.BadRequest, "No input body provided for write.");
            }

            if (string.IsNullOrEmpty(request.Path))
            {
                return request.CreateErrorResponse(HttpStatusCode.BadRequest, "Counter name must be specified.");
            }

            var counter = this.server.DataManager.GetCounter<Counter>(request.Path);
            if (counter == null)
            {
                return request.CreateErrorResponse(HttpStatusCode.NotFound, "Unknown counter name provided.");
            }

            var input = await request.ReadInputBody<CounterWriteRequest>();
            if (input == null)
            {
                return request.CreateErrorResponse(HttpStatusCode.BadRequest, "Could not deserialize input.");
            }
            if (input.Writes.Count == 0)
            {
                return request.CreateErrorResponse(HttpStatusCode.BadRequest, "No write operations were provided.");
            }

            // We want to do two passes here because if any of the operations are invalid we want to reject the entire
            // transaction.
            if (input.Writes.Any(operation => operation.Count < 1))
            {
                return request.CreateErrorResponse(HttpStatusCode.BadRequest,
                                                   "Operation counts must be greater than zero.");
            }

            foreach (var operation in input.Writes)
            {
                RunOperation(counter, operation);
            }

            return new Response(request, HttpStatusCode.Accepted, "Accepted");
        }

        public override async Task<Response> ProcessRequest(Request request)
        {
            var counterName = request.Path;
            if (string.IsNullOrEmpty(counterName))
            {
                return request.CreateErrorResponse(HttpStatusCode.BadRequest, "Path or command is invalid.");
            }

            if (request.QueryParameters.Count != 2
                || !request.QueryParameters.ContainsKey(ReservedDimensions.StartTimeDimension)
                || !request.QueryParameters.ContainsKey(ReservedDimensions.EndTimeDimension))
            {
                return request.CreateErrorResponse(HttpStatusCode.BadRequest,
                                                   "Invalid query parameters. Must specify only start and end time.");
            }

            DateTime start, end;
            if (!DateTime.TryParse(request.QueryParameters[ReservedDimensions.StartTimeDimension], out start))
            {
                return request.CreateErrorResponse(HttpStatusCode.BadRequest, "Invalid start time.");
            }
            if (!DateTime.TryParse(request.QueryParameters[ReservedDimensions.EndTimeDimension], out end))
            {
                return request.CreateErrorResponse(HttpStatusCode.BadRequest, "Invalid end time.");
            }

            var message = new TransferRequest();
            if (request.HasInputBody)
            {
                message = await request.ReadInputBody<TransferRequest>();
            }

            var ms = request.GetStream();

            // This is a tiered aggregation request, handle it separately.
            if (message.Sources != null && message.Sources.Count > 1)
            {
                try
                {
                    using (var aggregator =
                        PersistedDataProtocol.CreateAggregatorForSampleType(message.DataType, counterName,
                                                                            message.Sources, start, end,
                                                                            dataManager.MemoryStreamManager))
                    {
                        if (message.Timeout > 0)
                        {
                            aggregator.Timeout = TimeSpan.FromSeconds(message.Timeout);
                        }
                        if (message.MaxFanout > 0)
                        {
                            aggregator.MaxFanout = (int)message.MaxFanout;
                        }

                        // This shouldn't happen, given that one of the servers we want to talk to is.. us.
                        if (!await aggregator.Run())
                        {
                            ms.Dispose();
                            return request.CreateErrorResponse(HttpStatusCode.InternalServerError,
                                                               "All child requests failed.");
                        }
                        if (!aggregator.WriteToStream(ms))
                        {
                            // TODO: If we have no results but none of our queries failed we can definitively 404,
                            //       for now lazy.
                            ms.Dispose();
                            return request.CreateErrorResponse(HttpStatusCode.InternalServerError,
                                                               "No cntent matched.");
                        }
                    }
                }
                catch (ArgumentException)
                {
                    ms.Dispose();
                    return request.CreateErrorResponse(HttpStatusCode.BadRequest, "Request parameters are invalid.");
                }
            }
            else
            {
                var counter = this.dataManager.GetCounter<Counter>(counterName);
                if (counter == null || !counter.SerializeData(start, end, ms))
                {
                    ms.Dispose();
                    return request.CreateErrorResponse(HttpStatusCode.NotFound, "The requested data is not available.");
                }
            }

            // after writing the response the server will handle disposing the stream for us.
            return new Response(request, HttpStatusCode.OK, ms) {ContentType = ResponseType};
        }

        private async Task<Response> Info(Request request, TieredRequest fanoutRequest, string counterPattern,
                                          DimensionSpecification queryParameters)
        {
            var localResponseData = new CounterInfoResponse();
            foreach (var c in this.server.DataManager.Counters)
            {
                if (c.Name.MatchGlob(counterPattern))
                {
                    localResponseData.Counters.Add(BuildCounterInfo(c, queryParameters));
                }
            }

            // If there's no lower tier we can bounce out now.
            if (fanoutRequest == null)
            {
                return localResponseData.Counters.Count == 0
                           ? request.CreateErrorResponse(HttpStatusCode.NotFound, "No matching counters are defined.")
                           : Response.Create(request, HttpStatusCode.OK, localResponseData);
            }

            var distributedResponse =
                await
                this.server.CreateQueryClient(fanoutRequest)
                    .CounterInfoQuery(counterPattern, fanoutRequest, queryParameters);

            CounterInfoSampleCombiner.Merge(distributedResponse, localResponseData);
            // add details from this server if needed
            if (fanoutRequest.IncludeRequestDiagnostics && distributedResponse.RequestDetails != null)
            {
                distributedResponse.RequestDetails.Add(new RequestDetails
                                                       {
                                                           Server = this.server.ServerInfo,
                                                           IsAggregator = true,
                                                           HttpResponseCode = (localResponseData.Counters.Count > 0
                                                                                   ? (short)HttpStatusCode.OK
                                                                                   : (short)HttpStatusCode.NotFound),
                                                           Status = RequestStatus.Success,
                                                       });
            }

            return Response.Create(request, HttpStatusCode.OK, distributedResponse);
        }

 public override Task<Response> ProcessRequest(Request request)
 {
     return Task.FromResult(request.CreateErrorResponse(HttpStatusCode.NotFound, "Unknown command."));
 }