public void HttpRequestMessage_CopiesRequestMethod() { // Arrange var context = new DefaultHttpContext(); var feature = new HttpRequestMessageFeature(context); context.Request.Method = "OPTIONS"; // Act var request = feature.HttpRequestMessage; // Assert Assert.Equal(new HttpMethod("OPTIONS"), request.Method); }
protected HttpRequestMessage ConvertRequest() { HttpRequestMessageFeature hreqmf = new HttpRequestMessageFeature(this.HttpContext); HttpRequestMessage result = hreqmf.HttpRequestMessage; return(result); }
public async Task <IActionResult> ExtensionWebHookHandler(string name, CancellationToken token) { var provider = _scriptHostManager.BindingWebHookProvider; var handler = provider.GetHandlerOrNull(name); if (handler != null) { string keyName = WebJobsSdkExtensionHookProvider.GetKeyName(name); var authResult = await _authorizationService.AuthorizeAsync(User, keyName, PolicyNames.SystemAuthLevel); if (!authResult.Succeeded) { return(Unauthorized()); } var requestMessage = new HttpRequestMessageFeature(this.HttpContext).HttpRequestMessage; HttpResponseMessage response = await handler.ConvertAsync(requestMessage, token); var result = new ObjectResult(response); result.Formatters.Add(new HttpResponseMessageOutputFormatter()); return(result); } return(NotFound()); }
public async Task Invoke(HttpContext httpContext) { try { var request = httpContext.Request; var path = request.Path; var query = from item in _serversRecords where path.StartsWithSegments(item.PathStringBaseUrl) select item; var serverRecord = query.FirstOrDefault(); if (serverRecord != null) { var httpRequestMessageFeature = new HttpRequestMessageFeature(httpContext); var httpRequestMessage = httpRequestMessageFeature.HttpRequestMessage; HttpClient client = serverRecord.TestServer.CreateClient(); client.BaseAddress = new Uri($"{request.Scheme}://{request.Host}"); // trim off the front router hints path = path.Value.Substring(serverRecord.PathStringBaseUrl.Value.Length); var uriBuilder = new UriBuilder(request.Scheme, request.Host.Host) { Path = path, Query = request.QueryString.Value }; if (request.Host.Port != null) { uriBuilder.Port = (int)request.Host.Port; } httpRequestMessage.RequestUri = uriBuilder.Uri; httpRequestMessage.Headers.Remove("Host"); var responseMessage = await client.SendAsync(httpRequestMessage); httpContext.Response.StatusCode = (int)responseMessage.StatusCode; foreach (var header in responseMessage.Headers) { httpContext.Response.Headers[header.Key] = header.Value.ToArray(); } foreach (var header in responseMessage.Content.Headers) { httpContext.Response.Headers[header.Key] = header.Value.ToArray(); } // SendAsync removes chunking from the response. This removes the header so it doesn't expect a chunked response. httpContext.Response.Headers.Remove("transfer-encoding"); await responseMessage.Content.CopyToAsync(httpContext.Response.Body); return; } } catch (Exception ex) { _logger.LogCritical(ex, "Unhandled exception: {exception}", ex.Message); throw; } await _next(httpContext); }
/// <summary> /// Valide l'authentification de la requête passée en paramètre /// </summary> /// <param name="httpContext"></param> /// <returns></returns> public bool IsAuthenticated(HttpContext httpContext) { try { HttpRequestMessageFeature httpRequestMessageFeature = new HttpRequestMessageFeature(httpContext); HttpRequestMessage httpRequestMessage = httpRequestMessageFeature.HttpRequestMessage; if (!httpRequestMessage.Headers.Contains(CustomRequestHeaders.Email)) { return(false); } if (!httpRequestMessage.Headers.Date.HasValue) { return(false); } if (httpRequestMessage.Headers.Authorization == null) { return(false); } if (httpRequestMessage.Headers.Authorization.Scheme != CustomRequestHeaders.AuthorizationScheme) { return(false); } //Calcul de la clé d'accès secrète de l'utilisateur string email = httpRequestMessage.Headers.GetValues(CustomRequestHeaders.Email).First(); UserModel user = new Users().GetUsers().FirstOrDefault(x => x.Email == email); if (user == null) { return(false); } string accessKey = EncodingMethods.GetHashedString(user.Password); //Création de la demande canonique string canonicalRequest = EncodingMethods.GetCanonicalRequest(httpRequestMessage); if (canonicalRequest == null) { return(false); } //Création de la signature string signature = EncodingMethods.GetSignature(accessKey, canonicalRequest); if (signature == null) { return(false); } //Comparaison des deux signatures return(httpRequestMessage.Headers.Authorization.Parameter == signature); } catch { return(false); } }
internal static HttpRequestMessage GetRequestMessage(this HttpRequest request) { var feature = request.HttpContext.Features.Get <IHttpRequestMessageFeature>(); if (feature == null) { feature = new HttpRequestMessageFeature(request.HttpContext); request.HttpContext.Features.Set(feature); } return(feature.HttpRequestMessage); }
public static HttpRequestMessage GetHttpRequestMessage(this HttpContext httpContext) { var feature = httpContext.Features.Get<IHttpRequestMessageFeature>(); if (feature == null) { feature = new HttpRequestMessageFeature(httpContext); httpContext.Features.Set(feature); } return feature.HttpRequestMessage; }
internal async Task ProcessHttpInAndOutInvocationRequest(ScriptInvocationContext scriptInvocationContext) { _logger.LogDebug("Will invoke simple httpTrigger function: '{functionName}' invocationId: '{invocationId}'", scriptInvocationContext.FunctionMetadata.Name, scriptInvocationContext.ExecutionContext.InvocationId); ScriptInvocationResult scriptInvocationResult = new ScriptInvocationResult() { Outputs = new Dictionary <string, object>() }; HttpRequestMessage httpRequestMessage = null; (string name, DataType type, object request)input = scriptInvocationContext.Inputs.First(); HttpRequest httpRequest = input.request as HttpRequest; if (httpRequest == null) { throw new InvalidOperationException($"HttpTrigger value for: `{input.name}` is null"); } try { // Build HttpRequestMessage from HttpTrigger binding HttpRequestMessageFeature httpRequestMessageFeature = new HttpRequestMessageFeature(httpRequest.HttpContext); httpRequestMessage = httpRequestMessageFeature.HttpRequestMessage; AddRequestHeadersAndSetRequestUri(httpRequestMessage, scriptInvocationContext.FunctionMetadata.Name, scriptInvocationContext.ExecutionContext.InvocationId.ToString()); // Populate query params from httpTrigger string httpWorkerUri = QueryHelpers.AddQueryString(httpRequestMessage.RequestUri.ToString(), httpRequest.GetQueryCollectionAsDictionary()); httpRequestMessage.RequestUri = new Uri(httpWorkerUri); _logger.LogDebug("Sending http request message for simple httpTrigger function: '{functionName}' invocationId: '{invocationId}'", scriptInvocationContext.FunctionMetadata.Name, scriptInvocationContext.ExecutionContext.InvocationId); HttpResponseMessage invocationResponse = await _httpClient.SendAsync(httpRequestMessage); _logger.LogDebug("Received http response for simple httpTrigger function: '{functionName}' invocationId: '{invocationId}'", scriptInvocationContext.FunctionMetadata.Name, scriptInvocationContext.ExecutionContext.InvocationId); BindingMetadata httpOutputBinding = scriptInvocationContext.FunctionMetadata.OutputBindings.FirstOrDefault(); if (httpOutputBinding != null) { // handle http output binding scriptInvocationResult.Outputs.Add(httpOutputBinding.Name, invocationResponse); // handle $return scriptInvocationResult.Return = invocationResponse; } scriptInvocationContext.ResultSource.SetResult(scriptInvocationResult); } catch (Exception responseEx) { scriptInvocationContext.ResultSource.TrySetException(responseEx); } }
public StubHttpServer(string url) { webHost = WebHost.StartWith(url, app => { app.Run(async context => { var requestMessage = new HttpRequestMessageFeature(context).HttpRequestMessage; var responseMessage = handlers.FirstOrDefault(h => h.Expression(requestMessage))?.ValueCreator(); await ConvertToHttpResponseAsync(responseMessage, context.Response).ConfigureAwait(false); }); }); }
public async Task <HttpResponseMessage> getMetaData(string ConversationType) { var context = _httpContextAccessor.HttpContext; HttpRequestMessageFeature hreqmf = new HttpRequestMessageFeature(context); HttpRequestMessage request = hreqmf.HttpRequestMessage; MetadataModel metaData = new MetadataModel(); metaData = await metaDataRepository.getMetaData(ConversationType); return(GlobalFunctions.CreateResponse <MetadataModel>(request, HttpStatusCode.OK, metaData));; }
public async Task <IActionResult> ExtensionWebHookHandler(string extensionName, CancellationToken token, [FromServices] IScriptWebHookProvider provider) { if (provider.TryGetHandler(extensionName, out HttpHandler handler)) { var requestMessage = new HttpRequestMessageFeature(this.HttpContext).HttpRequestMessage; HttpResponseMessage response = await handler.ConvertAsync(requestMessage, token); var result = new ObjectResult(response); result.Formatters.Add(new HttpResponseMessageOutputFormatter()); return(result); } return(NotFound()); }
/// <summary> /// Create a new log /// </summary> /// <param name="context">Http context for current action</param> /// <returns>Successful result of log data</returns> public async Task <LogData> CreateLog(HttpContext context, string userName) { // Get message from context HttpRequestMessageFeature hreqmf = new HttpRequestMessageFeature(context); HttpRequestMessage req = hreqmf.HttpRequestMessage; DateTime dt = DateTime.Now; LogData log = new LogData() { Message = $"{req.Method.Method} call made by {userName} to {req.RequestUri.ToString()} on {String.Format("{0:ddd, MMM d, yyyy}", dt)} at {String.Format("{0:t}", dt)}." }; _context.Entry(log).State = EntityState.Added; await _context.SaveChangesAsync(); return(log); }
public void HttpRequestMessage_CopiesHeader() { // Arrange var context = new DefaultHttpContext(); var feature = new HttpRequestMessageFeature(context); context.Request.Method = "OPTIONS"; context.Request.Headers.Add("Host", new string[] { "contoso.com" }); // Act var request = feature.HttpRequestMessage; // Assert Assert.Equal("contoso.com", request.Headers.Host); }
public void HttpRequestMessage_CopiesContentHeader() { // Arrange var context = new DefaultHttpContext(); var feature = new HttpRequestMessageFeature(context); context.Request.Method = "OPTIONS"; context.Request.Headers.Add("Content-Type", new string[] { "text/plain" }); // Act var request = feature.HttpRequestMessage; // Assert Assert.Equal("text/plain", request.Content.Headers.ContentType.ToString()); }
public void HttpRequestMessage_CombinesUri() { // Arrange var context = new DefaultHttpContext(); var feature = new HttpRequestMessageFeature(context); context.Request.Method = "GET"; context.Request.Scheme = "http"; context.Request.Host = new HostString("contoso.com"); context.Request.PathBase = new PathString("/app"); context.Request.Path = new PathString("/api/Products"); context.Request.QueryString = new QueryString("?orderId=3"); // Act var request = feature.HttpRequestMessage; // Assert Assert.Equal("http://contoso.com/app/api/Products?orderId=3", request.RequestUri.AbsoluteUri); }
protected override async Task <AuthenticateResult> HandleAuthenticateAsync() { // Do we have authorization if (!AuthenticationHeaderValue.TryParse(Request.Headers["Authorization"], out var authorization)) { // No Authorization header, so ignore return(AuthenticateResult.NoResult()); } if (authorization.Scheme != Options.Scheme) { Logger.LogDebug("Not HMAC authenticated"); // Not our scheme, so ignore return(AuthenticateResult.NoResult()); } if (string.IsNullOrEmpty(authorization.Parameter)) { // Authentication was attempted but failed. Set ErrorResult to indicate an error. Logger.LogWarning("Missing credentials"); return(AuthenticateResult.Fail("Missing credentials")); } var httpRequest = new HttpRequestMessageFeature(Context); var identity = await authenticator.Authenticate(httpRequest.HttpRequestMessage); if (identity == null) { // Authentication was attempted but failed. Set ErrorResult to indicate an error. Logger.LogWarning("Invalid signature"); return(AuthenticateResult.Fail("Invalid signature")); } // Ok, wrap the identity in a principal and say we're ok. var principal = new ClaimsPrincipal(identity); var ticket = new AuthenticationTicket(principal, Options.Scheme); return(AuthenticateResult.Success(ticket)); }
public async Task <IActionResult> ExtensionWebHookHandler(string name, CancellationToken token, [FromServices] IScriptWebHookProvider provider) { if (provider.TryGetHandler(name, out HttpHandler handler)) { // must either be authorized at the admin level, or system level with // a matching key name string keyName = DefaultScriptWebHookProvider.GetKeyName(name); if (!AuthUtility.PrincipalHasAuthLevelClaim(User, AuthorizationLevel.System, keyName)) { return(Unauthorized()); } var requestMessage = new HttpRequestMessageFeature(this.HttpContext).HttpRequestMessage; HttpResponseMessage response = await handler.ConvertAsync(requestMessage, token); var result = new ObjectResult(response); result.Formatters.Add(new HttpResponseMessageOutputFormatter()); return(result); } return(NotFound()); }
public async Task <IActionResult> ExtensionWebHookHandler(string name, CancellationToken token, [FromServices] IScriptWebHookProvider provider) { if (provider.TryGetHandler(name, out HttpHandler handler)) { string keyName = DefaultScriptWebHookProvider.GetKeyName(name); var authResult = await _authorizationService.AuthorizeAsync(User, keyName, PolicyNames.SystemAuthLevel); if (!authResult.Succeeded) { return(Unauthorized()); } var requestMessage = new HttpRequestMessageFeature(this.HttpContext).HttpRequestMessage; HttpResponseMessage response = await handler.ConvertAsync(requestMessage, token); var result = new ObjectResult(response); result.Formatters.Add(new HttpResponseMessageOutputFormatter()); return(result); } return(NotFound()); }
// This method gets called by the runtime. Use this method to configure the HTTP request pipeline. public void Configure(IApplicationBuilder app, IWebHostEnvironment env) { app.UseCors("CORS"); var _microservices = new List <ServiceConfiguration>(); _configuration.Bind("services", _microservices); Console.WriteLine($"Microservices are null? {_microservices is null}"); var client = new HttpClient(); app.Run(async(ctx) => { var request = ctx.Request; Console.WriteLine($"\nMethod: {request.Method}\nPath: {request.Path}\nPathBase: {request.PathBase}\nHost: {request.Host}\nContentType: {request.ContentType}\n"); if (request.Method == "OPTIONS") { ctx.Response.StatusCode = 200; return; } var service = _microservices .FirstOrDefault( s => s.Routes .Any(r => request.Path.Value.StartsWith(r.Route) && r.Method == request.Method)); if (service is null) { Console.WriteLine("\nService is null => gateway not found error"); ctx.Response.StatusCode = 404; await ctx.Response.WriteAsync("Not found"); return; } HttpRequestMessageFeature feature = new HttpRequestMessageFeature(ctx); var message = feature.HttpRequestMessage; message.RequestUri = new Uri(service.Base + request.Path); // var message = await CreateMessage(service, request); var messageDescription = $"\nURI : {message.RequestUri}\nMethod: {message.Method}\n"; foreach (var header in message.Headers) { messageDescription += $"{header.Key}: "; foreach (var value in header.Value) { messageDescription += $"{value} "; } messageDescription += "\n"; } Console.WriteLine(messageDescription); try { var response = await client.SendAsync(message); Console.WriteLine($"\n{service.Service} responded with {(int)response.StatusCode} status code"); ctx.Response.StatusCode = (int)response.StatusCode; await ctx.Response.WriteAsync(await response.Content.ReadAsStringAsync()); return; } catch (Exception e) { Console.WriteLine("Exception occurred"); var body = $"Message: {e.Message}\nStackTrace: {e.StackTrace}"; ctx.Response.StatusCode = 500; await ctx.Response.WriteAsync(body); return; } }); }
public void HttpRequestMessage_CachesMessage() { // Arrange var context = new DefaultHttpContext(); var feature = new HttpRequestMessageFeature(context); context.Request.Method = "GET"; context.Request.Scheme = "http"; context.Request.Host = new HostString("contoso.com"); // Act var request1 = feature.HttpRequestMessage; context.Request.Path = new PathString("/api/Products"); var request2 = feature.HttpRequestMessage; // Assert Assert.Same(request1, request2); Assert.Equal("/", request2.RequestUri.AbsolutePath); }
public static HttpResponseMessage CreateCheckStatusResponse(this IDurableOrchestrationClient starter, HttpRequest request, string instanceId) { var httpRequestMessage = new HttpRequestMessageFeature(request.HttpContext).HttpRequestMessage; return(starter.CreateCheckStatusResponse(httpRequestMessage, instanceId)); }
public async Task HttpRequestMessage_WrapsBodyContent() { // Arrange var context = new DefaultHttpContext(); var feature = new HttpRequestMessageFeature(context); context.Request.Method = "OPTIONS"; var bytes = Encoding.UTF8.GetBytes("Hello, world!"); context.Request.Body = new MemoryStream(bytes); context.Request.Body.Seek(0, SeekOrigin.Begin); // Act var request = feature.HttpRequestMessage; // Assert var streamContent = Assert.IsType<StreamContent>(request.Content); var content = await request.Content.ReadAsStringAsync(); Assert.Equal("Hello, world!", content); }