HttpRequestMessage CreateHttpRequestMessage(RelayedHttpListenerContext context) { var requestMessage = new HttpRequestMessage(); if (context.Request.HasEntityBody) { requestMessage.Content = new StreamContent(context.Request.InputStream); string contentType = context.Request.Headers[HttpRequestHeader.ContentType]; if (!string.IsNullOrEmpty(contentType)) { requestMessage.Content.Headers.ContentType = new MediaTypeHeaderValue(contentType); } } string relativePath = context.Request.Url.GetComponents(UriComponents.PathAndQuery, UriFormat.Unescaped); relativePath = relativePath.Replace(this.hybridConnectionSubpath, string.Empty, StringComparison.OrdinalIgnoreCase); requestMessage.RequestUri = new Uri(relativePath, UriKind.RelativeOrAbsolute); requestMessage.Method = new HttpMethod(context.Request.HttpMethod); foreach (var headerName in context.Request.Headers.AllKeys) { if (string.Equals(headerName, "Host", StringComparison.OrdinalIgnoreCase) || string.Equals(headerName, "Content-Type", StringComparison.OrdinalIgnoreCase)) { // Don't flow these headers here continue; } requestMessage.Headers.Add(headerName, context.Request.Headers[headerName]); } return(requestMessage); }
private void RequestHandler(RelayedHttpListenerContext context) { try { this.logger?.LogMessage(LogLevel.Verbose, $"Request: {context.Request.HttpMethod} {context.Request.Url.AbsolutePath}"); PluginMethod method = this.FindMethod(context.Request.Url.AbsolutePath, context.Request.HttpMethod); if (method == null) { string message = $"Method not found. Uri = {context.Request.Url.AbsoluteUri}, Method = {context.Request.HttpMethod}"; this.logger?.LogMessage(LogLevel.Warning, message); context.Response.StatusCode = HttpStatusCode.NotFound; context.Response.StatusDescription = message; return; } try { this.logger?.LogMessage(LogLevel.Verbose, $"Execute: {method}"); method.Invoke(context); } catch (Exception e) { context.Response.StatusCode = HttpStatusCode.InternalServerError; this.logger?.LogException(e); } } finally { context.Response.Close(); } }
private void RequestHandler(RelayedHttpListenerContext context) { var streamReader = new StreamReader(context.Request.InputStream); // reading the body var requestContent = streamReader.ReadToEnd(); var message = JsonConvert.DeserializeObject <RemoteDebuggerMessage>(requestContent); CurrentResponseCache.AddOrUpdate(message.PluginExecutionId, context.Response, (guid, response) => context.Response); if (message.MessageType == RemoteDebuggerMessageType.Context) { var remoteContext = message.GetContext <RemoteDebugExecutionContext>(); OnContextReceived(remoteContext); MessageSendCache.TryAdd(remoteContext.Id, new RemoteDebuggerMessage(RemoteDebuggerMessageType.Context, remoteContext, remoteContext.Id)); } if (message.MessageType == RemoteDebuggerMessageType.Response) { MessageReceiveCache.TryAdd(message.PluginExecutionId, message); RemoteDebuggerMessage response; while (!MessageSendCache.TryRemove(message.PluginExecutionId, out response)) { // Waiting for the response to come Thread.Sleep(50); } //Console.WriteLine("{0}", response); SendMessage(response); } }
static void ProcessEventGridEvents(RelayedHttpListenerContext context) { var content = new StreamReader(context.Request.InputStream).ReadToEnd(); EventGridEvent[] eventGridEvents = JsonConvert.DeserializeObject <EventGridEvent[]>(content); foreach (EventGridEvent eventGridEvent in eventGridEvents) { Console.WriteLine($"Received event {eventGridEvent.Id} with type:{eventGridEvent.EventType}"); JObject dataObject = eventGridEvent.Data as JObject; if (string.Equals(eventGridEvent.EventType, StorageBlobCreatedEvent, StringComparison.OrdinalIgnoreCase)) { // Deserialize the data portion of the event into StorageBlobCreatedEventData var eventData = dataObject.ToObject <StorageBlobCreatedEventData>(); Console.WriteLine($"Got BlobCreated event data, blob URI {eventData.Url}"); } else if (string.Equals(eventGridEvent.EventType, CustomTopicEvent, StringComparison.OrdinalIgnoreCase)) { // Deserialize the data portion of the event into ContosoItemReceivedEventData var eventData = dataObject.ToObject <ContosoItemReceivedEventData>(); Console.WriteLine($"Got ContosoItemReceived event data, item SKU {eventData.ItemSku}"); } else { // This can be extended to any event type that Event Grid supports. Console.WriteLine($"Event with type {eventGridEvent.EventType} received, use proper type to deserialize data object"); } } }
public RequestContext(RelayedHttpListenerContext innerContext, Uri baseUri) { _cts = new CancellationTokenSource(); _innerContext = innerContext; _response = new Response(_innerContext.Response, baseUri); _request = new Request(_innerContext.Request, baseUri); IsUpgradableRequest = false; }
void SendErrorResponse(Exception e, RelayedHttpListenerContext context) { context.Response.StatusCode = HttpStatusCode.InternalServerError; #if DEBUG || INCLUDE_ERROR_DETAILS context.Response.StatusDescription = $"Internal Server Error: {e.GetType().FullName}: {e.Message}"; #endif context.Response.Close(); }
void LogRequest(DateTime startTimeUtc, RelayedHttpListenerContext context) { DateTime stopTimeUtc = DateTime.UtcNow; StringBuilder buffer = new StringBuilder(); buffer.Append($"{startTimeUtc.ToString("s", CultureInfo.InvariantCulture)}, "); buffer.Append($"\"{context.Request.HttpMethod} {context.Request.Url.GetComponents(UriComponents.PathAndQuery, UriFormat.Unescaped)}\", "); buffer.Append($"{(int)context.Response.StatusCode}, "); buffer.Append($"{(int)stopTimeUtc.Subtract(startTimeUtc).TotalMilliseconds}"); Console.WriteLine(buffer); }
/// <summary> /// Invoke the method using reflection. /// </summary> /// <param name="context">The listener context</param> internal void Invoke(RelayedHttpListenerContext context) { var result = this.MethodInfo.Invoke(this.Plugin, this.PrepareArguments(context.Request.Url.Query)); if (result != null) { using (var sw = new StreamWriter(context.Response.OutputStream)) { sw.WriteLine(result.ToString()); } } }
private static void HandleReceivedRequest(RelayedHttpListenerContext context, ILogger logger) { using (var requestStreamReader = new StreamReader(context.Request.InputStream)) { var rawEvents = requestStreamReader.ReadToEnd(); logger.LogInformation("New request was received - {rawEvents}", rawEvents); StoreReceivedEvents(rawEvents, logger); } // The context MUST be closed here context.Response.Close(); }
public static void ProcessRelayedHttpRequest(RelayedHttpListenerContext context) { // Do something with context.Request.Url, HttpMethod, Headers, InputStream... context.Response.StatusCode = HttpStatusCode.OK; context.Response.StatusDescription = "OK"; using (var sw = new StreamWriter(context.Response.OutputStream)) { sw.WriteLine("Current date and time for me is: " + DateTime.Now.ToString()); } // The context MUST be closed here context.Response.Close(); }
static void LogHttpRequest(RelayedHttpListenerContext context, TraceSource traceSource) { string requestBody = new StreamReader(context.Request.InputStream).ReadToEnd(); string output = $"Request: {context.Request.HttpMethod} {context.Request.Url} "; if (traceSource.Switch.ShouldTrace(TraceEventType.Verbose) && !string.IsNullOrEmpty(requestBody)) { output += Environment.NewLine + requestBody + Environment.NewLine; } output += $"({requestBody.Length} bytes, {context.TrackingContext.TrackingId})"; traceSource.TraceInformation(output); }
/// <summary> /// Handles the HTTP request received over the hybrid connection. /// </summary> /// <param name="context">Relayed request context.</param> /// <returns>Task tracking operation.</returns> private async Task HandleProxyRequestAsync(RelayedHttpListenerContext context) { RelayRequest relayRequest = new RelayRequest { Headers = context.Request.Headers, HttpMethod = new HttpMethod(context.Request.HttpMethod), InputStream = context.Request.InputStream, RequestPathAndQuery = context.Request.Url.AbsoluteUri.Substring(this.relayUrl.Length), RequestStartDateTime = DateTimeOffset.Now, }; try { RelayResponse relayResponse = await this.relayManager.HandleRelayRequestAsync(relayRequest).ConfigureAwait(false); context.Response.StatusCode = relayResponse.HttpStatusCode; context.Response.StatusDescription = relayResponse.StatusDescription; // Copy over outgoing headers. foreach (string headerName in relayResponse.Headers.Keys) { // Not copying over the Transfer-Encoding header as the communication between server and Relay, and Relay and client are // different connections. if (headerName.Equals("Transfer-Encoding", StringComparison.OrdinalIgnoreCase)) { continue; } context.Response.Headers[headerName] = relayResponse.Headers[headerName]; } if (relayResponse.OutputStream != null) { await relayResponse.OutputStream.CopyToAsync(context.Response.OutputStream).ConfigureAwait(false); } await context.Response.CloseAsync().ConfigureAwait(false); } catch (Exception ex) { context.Response.StatusCode = HttpStatusCode.InternalServerError; context.Response.StatusDescription = "Exception occurred at Server"; byte[] errorMessage = Encoding.UTF8.GetBytes(ex.Message); await context.Response.OutputStream.WriteAsync(errorMessage, 0, errorMessage.Length).ConfigureAwait(false); } }
async Task <bool> TestAcceptHandler(RelayedHttpListenerContext listenerContext) { string delayString = listenerContext.Request.Headers[TestAcceptHandlerDelayHeader]; TimeSpan delay; if (!string.IsNullOrEmpty(delayString) && TimeSpan.TryParse(delayString, out delay)) { await Task.Delay(delay); } string statusCodeString = listenerContext.Request.Headers[TestAcceptHandlerStatusCodeHeader]; int statusCode; if (!string.IsNullOrEmpty(statusCodeString) && int.TryParse(statusCodeString, out statusCode)) { listenerContext.Response.StatusCode = (HttpStatusCode)statusCode; } string statusDescription = listenerContext.Request.Headers[TestAcceptHandlerStatusDescriptionHeader]; if (!string.IsNullOrEmpty(statusDescription)) { listenerContext.Response.StatusDescription = statusDescription; } string responseHeaders = listenerContext.Request.Headers[TestAcceptHandlerSetResponseHeader]; if (!string.IsNullOrEmpty(responseHeaders)) { foreach (var headerAndValue in responseHeaders.Split(',')) { string[] headerNameAndValue = headerAndValue.Split(':'); listenerContext.Response.Headers[headerNameAndValue[0]] = headerNameAndValue[1].Trim(); } } bool result; if (!bool.TryParse(listenerContext.Request.Headers[TestAcceptHandlerResultHeader], out result)) { result = true; } TestUtility.Log($"Test AcceptHandler: {listenerContext.Request.Url} {(int)listenerContext.Response.StatusCode}: {listenerContext.Response.StatusDescription} returning {result}"); return(result); }
private async Task SendResponseAsync(RelayedHttpListenerContext context, HttpResponseMessage responseMessage) { context.Response.StatusCode = responseMessage.StatusCode; context.Response.StatusDescription = responseMessage.ReasonPhrase; foreach (var header in responseMessage.Headers) { if (string.Equals(header.Key, "Transfer-Encoding")) { continue; } context.Response.Headers.Add(header.Key, string.Join(",", header.Value)); } var responseStream = await responseMessage.Content.ReadAsStreamAsync(); await responseStream.CopyToAsync(context.Response.OutputStream); }
private HttpRequestMessage CreateHttpRequestMessage(RelayedHttpListenerContext context) { var requestMessage = new HttpRequestMessage(); if (context.Request.HasEntityBody) { requestMessage.Content = new StreamContent(context.Request.InputStream); // Experiment to see if I can capture the return message instead of having the bot responding directly (so far it doesn't work). //var contentStream = new MemoryStream(); //var writer = new StreamWriter(contentStream); //var newActivity = requestMessage.Content.ReadAsStringAsync().Result.Replace("https://directline.botframework.com/", "https://localhost:44372/"); //writer.Write(newActivity); //writer.Flush(); //contentStream.Position = 0; //requestMessage.Content = new StreamContent(contentStream); var contentType = context.Request.Headers[HttpRequestHeader.ContentType]; if (!string.IsNullOrEmpty(contentType)) { requestMessage.Content.Headers.ContentType = MediaTypeHeaderValue.Parse(contentType); } } var relativePath = context.Request.Url.GetComponents(UriComponents.PathAndQuery, UriFormat.Unescaped); relativePath = relativePath.Replace(_hybridConnectionSubPath, string.Empty, StringComparison.OrdinalIgnoreCase); requestMessage.RequestUri = new Uri(relativePath, UriKind.RelativeOrAbsolute); requestMessage.Method = new HttpMethod(context.Request.HttpMethod); foreach (var headerName in context.Request.Headers.AllKeys) { if (string.Equals(headerName, "Host", StringComparison.OrdinalIgnoreCase) || string.Equals(headerName, "Content-Type", StringComparison.OrdinalIgnoreCase)) { // Don't flow these headers here continue; } requestMessage.Headers.Add(headerName, context.Request.Headers[headerName]); } LogRequestActivity(requestMessage); return(requestMessage); }
/// <summary> /// Pre-check before accept. /// </summary> /// <param name="context"></param> /// <returns>Successful acceptance or not</returns> private Task <bool> OnAcceptAsync(RelayedHttpListenerContext context) { var id = context.Request.Headers["x-Id"]; if (!string.IsNullOrEmpty(id) && Reference.TryParse(id, out var streamId)) { if (_connectionMap.TryGetValue(streamId, out var connection)) { // We correlate context and relay stream by finding // the stream id in the stream's tracking id if (context.ToString().ToLower().Contains(id.ToLower())) { return(Task.FromResult(true)); } } } ProxyEventSource.Log.ConnectionRejected(context, null); return(Task.FromResult(false)); }
async void RequestHandler(RelayedHttpListenerContext context) { DateTime startTimeUtc = DateTime.UtcNow; try { HttpRequestMessage requestMessage = CreateHttpRequestMessage(context); HttpResponseMessage responseMessage = await this.httpClient.SendAsync(requestMessage); await SendResponseAsync(context, responseMessage); await context.Response.CloseAsync(); } catch (Exception e) { Console.WriteLine($"Error: {e.GetType().Name}: {e.Message}"); SendErrorResponse(e, context); } finally { LogRequest(startTimeUtc, context); } }
void LogRequest(DateTime startTimeUtc, RelayedHttpListenerContext context) { DateTime stopTimeUtc = DateTime.UtcNow; _libHoney.SendNow(new Dictionary <string, object> () { ["name"] = "HybridConnectionReverseProxy", ["service_name"] = "HybridConnectionReverseProxy", ["duration_ms"] = (int)stopTimeUtc.Subtract(startTimeUtc).TotalMilliseconds, ["method"] = context.Request.HttpMethod, ["status_code"] = $"{(int)context.Response.StatusCode}", ["azFunction"] = "GetTemps", ["endpoint"] = $"\"{context.Request.Url.GetComponents(UriComponents.PathAndQuery, UriFormat.Unescaped)}\"", }); StringBuilder buffer = new StringBuilder(); buffer.Append($"{startTimeUtc.ToString("s", CultureInfo.InvariantCulture)}, "); buffer.Append($"\"{context.Request.HttpMethod} {context.Request.Url.GetComponents(UriComponents.PathAndQuery, UriFormat.Unescaped)}\", "); buffer.Append($"{(int)context.Response.StatusCode}, "); buffer.Append($"{(int)stopTimeUtc.Subtract(startTimeUtc).TotalMilliseconds}"); Console.WriteLine(buffer); }
static async void SomebodyCalled(RelayedHttpListenerContext context) { //StreamReader sr = new StreamReader(context.Request.InputStream); Request req = await JsonSerializer .DeserializeAsync <Request>( utf8Json : context.Request.InputStream, options : new JsonSerializerOptions { PropertyNameCaseInsensitive = true }); Console.WriteLine($"Somebody called, with the following command: {req.Command}\tFilePath is : {req.FilePath}"); context.Response.Close(); return; var files = Directory.GetFiles(req.FilePath); List <object> resultList = new List <object>(); foreach (string file in files) { resultList.Add(new { file = file }); } var resultObject = resultList.ToArray(); var json = JsonSerializer .Serialize(value: resultObject, options: new JsonSerializerOptions { WriteIndented = true }); context.Response.Headers.Add("content-type", "application/json"); using (var sw = new StreamWriter(context.Response.OutputStream)) { await sw.WriteLineAsync(json); } context.Response.Close(); }
private async void ListenerRequestHandler(RelayedHttpListenerContext context) { var startTimeUtc = DateTime.UtcNow; try { Console.WriteLine("Calling {0}...", _targetServiceAddress); var requestMessage = CreateHttpRequestMessage(context); var responseMessage = await _httpClient.SendAsync(requestMessage); await SendResponseAsync(context, responseMessage); await context.Response.CloseAsync(); } catch (Exception ex) { LogException(ex); SendErrorResponse(ex, context); } finally { LogRequest(startTimeUtc); } }
private void SendErrorResponse(Exception ex, RelayedHttpListenerContext context) { context.Response.StatusCode = HttpStatusCode.InternalServerError; context.Response.StatusDescription = $"Internal Server Error: {ex.GetType().FullName}: {ex.Message}"; context.Response.Close(); }
async Task QueryString(EndpointTestType endpointTestType) { HybridConnectionListener listener = this.GetHybridConnectionListener(endpointTestType); try { RelayConnectionStringBuilder connectionString = GetConnectionStringBuilder(endpointTestType); Uri endpointUri = connectionString.Endpoint; TestUtility.Log("Calling HybridConnectionListener.Open"); await listener.OpenAsync(TimeSpan.FromSeconds(30)); var queryStringTests = new[] { new { Original = "?foo=bar", Output = "?foo=bar" }, new { Original = "?sb-hc-id=1", Output = "" }, new { Original = "?sb-hc-id=1&custom=value", Output = "?custom=value" }, new { Original = "?custom=value&sb-hc-id=1", Output = "?custom=value" }, new { Original = "?sb-hc-undefined=true", Output = "" }, new { Original = "? Key = Value With Space ", Output = "?+Key+=++Value+With+Space" }, // HttpUtility.ParseQueryString.ToString() in the cloud service changes this new { Original = "?key='value'", Output = "?key=%27value%27" }, // HttpUtility.ParseQueryString.ToString() in the cloud service changes this new { Original = "?key=\"value\"", Output = "?key=%22value%22" }, // HttpUtility.ParseQueryString.ToString() in the cloud service changes this new { Original = "?key=<value>", Output = "?key=%3cvalue%3e" }, #if PENDING_SERVICE_UPDATE new { Original = "?foo=bar&", Output = "?foo=bar&" }, new { Original = "?&foo=bar", Output = "?foo=bar" }, // HttpUtility.ParseQueryString.ToString() in the cloud service changes this new { Original = "?sb-hc-undefined", Output = "?sb-hc-undefined" }, new { Original = "?CustomValue", Output = "?CustomValue" }, new { Original = "?custom-Value", Output = "?custom-Value" }, new { Original = "?custom&value", Output = "?custom&value" }, new { Original = "?&custom&value&", Output = "?&custom&value&" }, new { Original = "?&&value&&", Output = "?&&value&&" }, new { Original = "?+", Output = "?+" }, new { Original = "?%20", Output = "?+" }, // HttpUtility.ParseQueryString.ToString() in the cloud service changes this new { Original = "? Not a key value pair ", Output = "?+Not+a+key+value+pair" }, // HttpUtility.ParseQueryString.ToString() in the cloud service changes this new { Original = "?&+&", Output = "?&+&" }, new { Original = "?%2f%3a%3d%26", Output = "?%2f%3a%3d%26" }, #endif }; RelayedHttpListenerContext actualRequestContext = null; listener.RequestHandler = async(context) => { TestUtility.Log($"RequestHandler {context.Request.HttpMethod} {context.Request.Url}"); actualRequestContext = context; await context.Response.CloseAsync(); }; foreach (var queryStringTest in queryStringTests) { string originalQueryString = queryStringTest.Original; string expectedQueryString = queryStringTest.Output; actualRequestContext = null; TestUtility.Log($"Testing Query String '{originalQueryString}'"); Uri hybridHttpUri = new UriBuilder("https://", endpointUri.Host, endpointUri.Port, connectionString.EntityPath, originalQueryString).Uri; using (var client = new HttpClient { BaseAddress = hybridHttpUri }) { client.DefaultRequestHeaders.ExpectContinue = false; var getRequest = new HttpRequestMessage(); getRequest.Method = HttpMethod.Get; await AddAuthorizationHeader(connectionString, getRequest, hybridHttpUri); LogRequestLine(getRequest, client); using (HttpResponseMessage response = await client.SendAsync(getRequest)) { LogResponseLine(response); Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Equal(expectedQueryString, actualRequestContext.Request.Url.Query); } } } await listener.CloseAsync(TimeSpan.FromSeconds(10)); } finally { await SafeCloseAsync(listener); } }
Task <bool> WebSocketAcceptHandler(RelayedHttpListenerContext arg) { return(Task <bool> .FromResult(true)); }