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);
}
