/// <inheritdoc /> public async Task <Response> SendAsync(Request request, TimeSpan?connectionTimeout, TimeSpan timeout, CancellationToken cancellationToken) { if (timeout.TotalMilliseconds < 1) { LogRequestTimeout(request, timeout); return(new Response(ResponseCode.RequestTimeout)); } var state = new WebRequestState(timeout); using (var timeoutCancellation = new CancellationTokenSource()) { var timeoutTask = Task.Delay(state.TimeRemaining, timeoutCancellation.Token); var senderTask = SendInternalAsync(request, state, connectionTimeout, cancellationToken); var completedTask = await Task.WhenAny(timeoutTask, senderTask).ConfigureAwait(false); if (completedTask is Task <Response> taskWithResponse) { timeoutCancellation.Cancel(); return(taskWithResponse.GetAwaiter().GetResult()); } // If the completed task can not be cast to Task<Response>, it means that timeout task has completed. state.CancelRequest(); LogRequestTimeout(request, timeout); // Wait a little for canceled sending task completion before returning result: var senderTaskContinuation = senderTask.ContinueWith( t => { if (t.IsCompleted) { t.GetAwaiter().GetResult().Dispose(); } }); var abortWaitingDelay = Task.Delay(Settings.RequestAbortTimeout); await Task.WhenAny(senderTaskContinuation, abortWaitingDelay).ConfigureAwait(false); if (!senderTask.IsCompleted) { LogFailedToWaitForRequestAbort(); } return(responseFactory.BuildResponse(ResponseCode.RequestTimeout, state)); } }
public Task HandleRequestAsync(HttpListenerContext context) { var allowValues = new List <string>(); var request = context.Request; foreach (var requestProcessor in _requestProcessors) { if (request.Url.LocalPath.Trim('/') == requestProcessor.SubUri) { allowValues.Add(requestProcessor.Method.Method); if (requestProcessor.Method == HttpMethod.Get) { allowValues.Add("HEAD"); } } } if (allowValues.Any()) { ResponseFactory.BuildResponse(context, HttpStatusCode.OK, null); context.Response.AddHeader("Allow", string.Join(", ", allowValues)); } else { ResponseFactory.BuildResponse(context, HttpStatusCode.NotFound, null); } return(Task.FromResult(0)); }
private Task HandleFileHeadRequestAsync(HttpListenerContext context, string filePath) { if (FilesPreprocessingEnabled && FilePreprocessController.FileInProgress(filePath)) { LogDebug($"File {filePath} was requested but is in progress"); ResponseFactory.BuildResponse(context, HttpStatusCode.ServiceUnavailable, null); return(Task.FromResult(0)); } if (!File.Exists(filePath)) { LogDebug($"File {filePath} was requested but was not found"); ResponseFactory.BuildResponse(context, HttpStatusCode.NotFound, null); return(Task.FromResult(0)); } var response = context.Response; var fileInfo = new FileInfo(filePath); response.ContentLength64 = fileInfo.Length; response.StatusCode = (int)HttpStatusCode.OK; response.ContentType = MimeTypes.GetTypeByExtenstion(Path.GetExtension(filePath).Substring(1)); return(Task.FromResult(0)); }
public Task HandleRequestAsync(HttpListenerContext context) { var responseBody = new PingResponse(CommonHelper.SerializeHttpRequest(context, true)); ResponseFactory.BuildResponse(context, HttpStatusCode.OK, responseBody); return(Task.FromResult(0)); }
public async Task HandleFaviconAsync(HttpListenerContext context) { var response = context.Response; LogTrace($"Favicon requested, path: {FaviconPath}"); if (string.IsNullOrEmpty(FaviconPath) || !File.Exists(FaviconPath)) { ResponseFactory.BuildResponse(context, HttpStatusCode.NotFound, null); return; } ResponseFactory.BuildResponse(context, HttpStatusCode.OK, null); response.ContentType = "image/x-icon"; using (var fileStream = new FileStream(FaviconPath, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) { await fileStream.CopyToAsync(response.OutputStream).ConfigureAwait(false); } }
public async Task HandleRequestAsync(HttpListenerContext context) { AuthentificationResult authResult; var request = context.Request; if (_authentificator != null) { authResult = await _authentificator.Invoke(request); } else { authResult = new AuthentificationResult(null, HttpStatusCode.NotFound); } if (authResult == null) { throw new InvalidOperationException("Authentificator fault: null result"); } ResponseFactory.BuildResponse(context, authResult); }
private async Task HandleFileGetRequestAsync(HttpListenerContext context, string filePath) { if (FilesPreprocessingEnabled && FilePreprocessController.FileInProgress(filePath)) { LogDebug($"File {filePath} was requested but is in progress"); ResponseFactory.BuildResponse(context, HttpStatusCode.ServiceUnavailable, null); return; } var fileRequest = FileRequestFactory.BuildRequest(filePath, context.Request); if (fileRequest == null) { LogDebug($"Failed to build file request for {filePath}"); ResponseFactory.BuildResponse(context, HttpStatusCode.BadRequest, null); return; } await fileRequest.BuildResponse(context); }
public void Given_a_Valid_Road_Id_Is_Specified_Return_Road_Name() { //Arrange responseFactory = new ResponseFactory(); var _mock = new Mock <IResponseFactory>(); _JObjectFactory = new Mock <IJObjectFactory>(); //Act _mock.Setup(x => x.BuildResponse(It.IsAny <JObject>())).Returns(responseFactory.BuildResponse(MockResponse.ValidResponse("a4"))); _JObjectFactory.Setup(o => o.ReturnAsJObect(MockResponse.ValidHttpResponseMock("A4"))).Equals(typeof(JObject)); //Assert _JObjectFactory.Verify(); _mock.Should().NotBeNull(); //JB. Check that the Road name is returned. _mock.Object.BuildResponse(MockResponse.ValidResponse("a4")).Should().Contain("A4"); }
public static void TestResponseXml() { XmlDocument testDoc = new XmlDocument(); // testDoc.AppendChild(testDoc.CreateElement("methodResponse")); // testDoc.LoadXml("<methodResponse><fault><value><struct><member><name>faultCode</name><value><int>1</int></value></member><member><name>faultString</name><value><string>Error</string></value></member></struct></value></fault></methodResponse>"); testDoc.LoadXml("<methodResponse><params><param><value><array><data><value><int>7</int></value><value><int>11</int></value><value><int>8</int></value><value><int>44</int></value><value><int>10</int></value><value><int>12</int></value></data></array></value></param></params></methodResponse>"); testDoc.Save(Console.Out); XmlRpcResponse response = ResponseFactory.BuildResponse(testDoc); if (response.IsFault()) { Console.WriteLine(response.GetFaultString()); } else { Console.WriteLine(); Console.WriteLine(); Console.WriteLine(response.GetString()); } }
private void HandleFileDeleteRequest(HttpListenerContext context, string filePath) { if (!File.Exists(filePath)) { LogDebug($"File {filePath} does not exist and cannot be deleted"); ResponseFactory.BuildResponse(context, HttpStatusCode.NotFound, null); return; } var compressed = IoHelper.LoadAllChanged(filePath); try { File.Delete(filePath); compressed.ForEach(File.Delete); ResponseFactory.BuildResponse(context, HttpStatusCode.OK, null); } catch (Exception ex) { LogException(LogLevel.Warning, ex); ResponseFactory.BuildResponse(context, HttpStatusCode.InternalServerError, null); } }
private async Task HandleFilePostRequestAsync(HttpListenerContext context, FileSection section, string filePath) { if (File.Exists(filePath)) { LogDebug($"File {filePath} already exists"); ResponseFactory.BuildResponse(context, HttpStatusCode.Conflict, null); return; } var fileContent = context.Request.InputStream; var contentLength = context.Request.ContentLength64; if (section.MaxFileSize > 0 && contentLength > section.MaxFileSize) { LogDebug($"Trying to create file of size {contentLength} in section {section.Name} with max size of {section.MaxFileSize}"); ResponseFactory.BuildResponse(context, HttpStatusCode.RequestEntityTooLarge, null); return; } using (var file = new FileStream(filePath, FileMode.Create, FileAccess.ReadWrite, FileShare.ReadWrite)) { await fileContent.CopyToAsync(file).ConfigureAwait(false); await file.FlushAsync(); } GC.Collect(1); LogTrace($"Total memory: {GC.GetTotalMemory(true)}"); LogDebug($"File {filePath} created"); if (FilesPreprocessingEnabled) { var code = FilePreprocessController.EnqueueFile(filePath) ? HttpStatusCode.Accepted : HttpStatusCode.Created; ResponseFactory.BuildResponse(context, code, null); } else { ResponseFactory.BuildResponse(context, HttpStatusCode.Created, null); } }
public async Task HandleRequestAsync(HttpListenerContext context) { var response = context.Response; if (_statisticsAuthorizer != null) { if (await _statisticsAuthorizer.Invoke(context.Request)) { var responseBody = Statistics?.Serialize(); ResponseFactory.BuildResponse(context, HttpStatusCode.OK, responseBody, null, true); response.ContentType = "text/plain"; } else { ResponseFactory.BuildResponse(context, HttpStatusCode.Forbidden, null); } } else { var responseBody = Statistics?.Serialize(); ResponseFactory.BuildResponse(context, HttpStatusCode.OK, responseBody, null, true); response.ContentType = "text/plain"; } }
protected async Task BuildRangeResponse(HttpListenerContext context, string fileName) { var response = context.Response; if (!File.Exists(fileName)) { LogDebug($"File {fileName} was requested but not found"); ResponseFactory.BuildResponse(context, HttpStatusCode.NotFound, null); return; } if (Range == null) { response.StatusCode = (int)HttpStatusCode.OK; response.ContentType = DetermineContentType(fileName); var fileLength = new FileInfo(fileName).Length; response.ContentLength64 = fileLength; ResponseFactory.SerializeResponse(response, null); using (var fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) { try { var bufferSize = fileLength >= LargeFileSizeThreshold ? LargeFileBufferSize : SmallFileBufferSize; await fileStream.CopyToAsync(response.OutputStream, bufferSize); } catch (HttpListenerException ex) { LogMessage(LogLevel.Debug, $"Error: {ex.Message}"); } } return; } var fileInfo = new FileInfo(fileName); long startPosition = 0; var endPosition = fileInfo.Length - 1; if (Range.RangeEnd != null) { var rangeEnd = Range.RangeEnd.Value; if (rangeEnd < 0) { if (fileInfo.Length < -rangeEnd) { response.StatusCode = (int)HttpStatusCode.RequestedRangeNotSatisfiable; response.AddHeader("Content-Range", $"bytes 0-{fileInfo.Length - 1}"); ResponseFactory.SerializeResponse(response, null); return; } startPosition = fileInfo.Length + rangeEnd; endPosition = fileInfo.Length - 1; } if (rangeEnd > 0) { if (fileInfo.Length < rangeEnd) { response.StatusCode = (int)HttpStatusCode.RequestedRangeNotSatisfiable; response.AddHeader("Content-Range", $"bytes 0-{fileInfo.Length - 1}"); ResponseFactory.SerializeResponse(response, null); return; } endPosition = rangeEnd; } } if (Range.RangeStart != null) { startPosition = Range.RangeStart.Value; } byte[] buffer; var length = endPosition - startPosition + 1; using (var fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) { using (var reader = new BinaryReader(fileStream)) { reader.BaseStream.Seek(startPosition, SeekOrigin.Begin); buffer = reader.ReadBytes((int)length); } } response.StatusCode = (int)HttpStatusCode.PartialContent; response.AddHeader("Content-Range", $"bytes {startPosition}-{endPosition}"); response.ContentType = DetermineContentType(fileName); response.ContentLength64 = buffer.Length; ResponseFactory.SerializeResponse(response, null); try { await response.OutputStream.WriteAsync(buffer, 0, buffer.Length); } catch (HttpListenerException ex) { LogMessage(LogLevel.Debug, $"Error: {ex.Message}"); } }
public Task HandleRequestAsync(HttpListenerContext context) { ResponseFactory.BuildResponse(context, HttpStatusCode.OK, _configuration); return(Task.FromResult(0)); }
public void Given_a_Valid_Road_Id_Is_Specified_Return_Road_Status() { //Arrange responseFactory = new ResponseFactory(); _ResponseFactory = new Mock <IResponseFactory>(); //Act _ResponseFactory.Setup(x => x.BuildResponse(It.IsAny <JObject>())).Returns(responseFactory.BuildResponse(MockResponse.ValidResponse("a4"))); _ResponseFactory.Verify(); //Assert //Assert.That(_ResponseFactory.Object, Is.Not.Null); _ResponseFactory.Object.Should().NotBeNull(); //JB. Check that the Road status is returned //Assert.That(_ResponseFactory.Object.BuildResponse(MockResponse.ValidResponse("a4")), Contains.Substring("Road status")); _ResponseFactory.Object.BuildResponse(MockResponse.ValidResponse("a4")).Should().Contain("Road status"); }
public void Given_a_Valid_Road_Id_Is_Specified_Return_Road_Status_Description() { //Arrange responseFactory = new ResponseFactory(); _ResponseFactory = new Mock <IResponseFactory>(); _ResponseFactory.Setup(x => x.BuildResponse(It.IsAny <JObject>())).Returns(responseFactory.BuildResponse(MockResponse.ValidResponse("a4"))); //Act _ResponseFactory.Verify(); //Assert _ResponseFactory.Object.Should().NotBeNull(); //JB. Check that the Road status Description is returned _ResponseFactory.Object.BuildResponse(MockResponse.ValidResponse("a2")).Should().Contain("Road status Description"); }
public async Task HandleFileRequestAsync(HttpListenerContext context) { if (!_started) { ResponseFactory.BuildResponse(context, HttpStatusCode.NotImplemented, null); return; } var request = context.Request; try { var filename = ExtractFileName(request.Url.LocalPath); var section = ExtractFileSection(request.Url.LocalPath); if (filename == null || section == null || filename.Contains("_CHANGED_")) { ResponseFactory.BuildResponse(context, HttpStatusCode.BadRequest, null); return; } var filePath = FilesLocation + Path.DirectorySeparatorChar + section.Folder + Path.DirectorySeparatorChar + filename; AuthorizationResult <TAccount> authResult; if (FilesNeedAuthorization) { authResult = await _filesAuthorizer.Invoke(request, section, filename).ConfigureAwait(false); } else { authResult = new AuthorizationResult <TAccount>(null, AuthorizationStatus.NotRequired); } _statistics?.AddAuthResult(authResult); switch (authResult.Status) { case AuthorizationStatus.NotRequired: case AuthorizationStatus.Ok: if (CommonHelper.HttpMethodToEnum(request.HttpMethod) == HttpMethod.Get) { await HandleFileGetRequestAsync(context, filePath).ConfigureAwait(false); return; } if (CommonHelper.HttpMethodToEnum(request.HttpMethod) == HttpMethod.Head) { await HandleFileHeadRequestAsync(context, filePath).ConfigureAwait(false); return; } if (CommonHelper.HttpMethodToEnum(request.HttpMethod) == HttpMethod.Post) { await HandleFilePostRequestAsync(context, section, filePath).ConfigureAwait(false); return; } if (CommonHelper.HttpMethodToEnum(request.HttpMethod) == HttpMethod.Delete) { HandleFileDeleteRequest(context, filePath); return; } ResponseFactory.BuildResponse(context, HttpStatusCode.MethodNotAllowed, null); return; default: ResponseFactory.BuildResponse(context, authResult); return; } } catch (Exception exception) { LogException(LogLevel.Warning, exception); ResponseFactory.BuildResponse(context, HttpStatusCode.InternalServerError, null); } }