static void PrepareAuthentication(HttpOptions options, HttpWebRequest request)
{
var basic_auth = options.AdditionalOptions.basic_auth;
if (basic_auth != null)
{
options.BasicAuth(basic_auth.username, basic_auth.password);
}
}
private static void RegisterPipelineMiddleware(HttpOptions options, IEnumerable<ResponseMiddleware> responseMiddlewares, IAppBuilder app)
{
app.Use<DiscoverCommand>(options.CommandNameResolver, options.CommandFactory);
foreach (var middleware in responseMiddlewares)
{
app.Use(middleware.MiddlewareType, middleware.Arguments);
}
app.Use<ExecuteCommandPipeline>(options.CommandPipeline);
}
// TODO hrm
public HttpWebRequest Build(HttpOptions options)
{
var request = (HttpWebRequest) WebRequest.Create(options.BaseUri);
request.Method = options.Method;
PrepareRequestStream(options, request);
PrepareAuthentication(options, request);
options.Configure(request);
return request;
}
public static void UseSequin(this IAppBuilder app, HttpOptions options, IEnumerable<ResponseMiddleware> responseMiddlewares)
{
app.UseRequestScopeContext();
app.Use((ctx, next) =>
{
ctx.Set("CommandEndpointPath", new PathString(options.CommandPath));
return next();
});
app.Use(typeof(HandleHttpOptions));
app.MapWhen(x => ShouldExecuteCommandPipeline(x, options.CommandPath), x =>
{
RegisterPipelineMiddleware(options, responseMiddlewares, x);
});
}
private Promise<IHttpResponse, Error> Request(string method, Uri url, Dictionary<string, string> headers, byte[] postData = null, HttpOptions options = null)
{
options = options == null ? new HttpOptions() : options;
var promise = new Promise<IHttpResponse, Error>();
var headersStr = ObjectParser.Save(headers);
var optionsStr = ObjectParser.Save(options);
var requestId = 0;
var callbackInfo = ServiceProvider.Get().externalCallback.Make(
(data) => promise.Accept(new HttpWebGLResponse(requestId, url))
);
if (method == "GET") {
requestId = MakeGetRequest(url.AbsoluteUri, headersStr, optionsStr, callbackInfo);
} else if(method == "POST") {
var pinnedBuffer = GCHandle.Alloc(postData, GCHandleType.Pinned);
requestId = MakePostRequest(url.AbsoluteUri, headersStr, pinnedBuffer.AddrOfPinnedObject(), postData.Length, optionsStr, callbackInfo);
pinnedBuffer.Free();
}
return promise;
}
void PrepareRequestStream(HttpOptions options, HttpWebRequest result)
{
if (options.Method == "post")
{
var query = options.AdditionalOptions.query;
if (query != null)
{
string json = _jsonSerializer.ToJson(query);
result.ContentLength = Encoding.UTF8.GetBytes(json).Length;
using (TextWriter writer = new StreamWriter(result.GetRequestStream()))
{
writer.Write(json);
}
}
else
{
result.ContentLength = 0;
}
}
}
public HttpConnection(Uri url, TransportType transportType, ILoggerFactory loggerFactory, HttpOptions httpOptions)
{
Url = url ?? throw new ArgumentNullException(nameof(url));
_loggerFactory = loggerFactory ?? NullLoggerFactory.Instance;
_logger = _loggerFactory.CreateLogger <HttpConnection>();
_httpOptions = httpOptions;
_requestedTransportType = transportType;
if (_requestedTransportType != TransportType.WebSockets)
{
_httpClient = CreateHttpClient();
}
_transportFactory = new DefaultTransportFactory(transportType, _loggerFactory, _httpClient, httpOptions);
_logScope = new ConnectionLogScope();
_scopeDisposable = _logger.BeginScope(_logScope);
}
public void DecompressionMethods_ByDefault_AllBitsSet()
{
var sut = new HttpOptions(DsnSamples.Valid.SentryUri);
Assert.Equal(~DecompressionMethods.None, sut.DecompressionMethods);
}
public HttpConnection(Uri url, ITransportFactory transportFactory, ILoggerFactory loggerFactory, HttpOptions httpOptions)
{
Url = url ?? throw new ArgumentNullException(nameof(url));
_loggerFactory = loggerFactory ?? NullLoggerFactory.Instance;
_logger = _loggerFactory.CreateLogger <HttpConnection>();
_httpOptions = httpOptions;
_httpClient = CreateHttpClient();
_transportFactory = transportFactory ?? throw new ArgumentNullException(nameof(transportFactory));
_logScope = new ConnectionLogScope();
_scopeDisposable = _logger.BeginScope(_logScope);
}
public static void UseTmqOverWebSockets(this TwinoServer server, HorseMq mq, HttpOptions options)
{
throw new NotImplementedException();
}
public HttpConnection(Uri url, ITransportFactory transportFactory, ILoggerFactory loggerFactory, HttpOptions httpOptions)
{
Url = url ?? throw new ArgumentNullException(nameof(url));
_loggerFactory = loggerFactory ?? NullLoggerFactory.Instance;
_logger = _loggerFactory.CreateLogger <HttpConnection>();
_httpOptions = httpOptions;
_httpClient = _httpOptions?.HttpMessageHandler == null ? new HttpClient() : new HttpClient(_httpOptions?.HttpMessageHandler);
_httpClient.Timeout = HttpClientTimeout;
_transportFactory = transportFactory ?? throw new ArgumentNullException(nameof(transportFactory));
}
/// <summary>
/// Uses HTTP Protocol and accepts HTTP connections with Horse MVC Architecture
/// </summary>
public static IHorseServer UseMvc(this IHorseServer server, HorseMvc mvc)
{
return(UseMvc(server, mvc, HttpOptions.CreateDefault()));
}
/// <summary>
/// Uses HTTP Protocol and accepts HTTP connections with Twino MVC Architecture
/// </summary>
public static ITwinoServer UseMvc(this ITwinoServer server, TwinoMvc mvc, string optionsFilename)
{
return(UseMvc(server, mvc, HttpOptions.Load(optionsFilename)));
}
internal static Response post(HttpOptions httpOptions)
{
return _requestor.Post(httpOptions);
}
public static void UseSequin(this IAppBuilder app, HttpOptions options)
{
app.UseSequin(options, new ResponseMiddleware[0]);
}
/// <summary>
/// Uses WebSocket Protocol and accepts HTTP connections which comes with "Upgrade: websocket" header data
/// </summary>
public static ITwinoServer UseWebSockets(this ITwinoServer server,
WebSocketMessageRecievedHandler handlerAction)
{
return(UseWebSockets(server, new MethodWebSocketConnectionHandler(handlerAction), HttpOptions.CreateDefault()));
}
internal static Response get(HttpOptions httpOptions)
{
return _requestor.Get(httpOptions);
}
public static async Task SendMessages(Uri sendUrl, IDuplexPipe application, HttpClient httpClient,
HttpOptions httpOptions, CancellationTokenSource transportCts, ILogger logger)
{
logger.SendStarted();
try
{
while (true)
{
var result = await application.Input.ReadAsync(transportCts.Token);
var buffer = result.Buffer;
try
{
// Grab as many messages as we can from the channel
transportCts.Token.ThrowIfCancellationRequested();
if (!buffer.IsEmpty)
{
logger.SendingMessages(buffer.Length, sendUrl);
// Send them in a single post
var request = new HttpRequestMessage(HttpMethod.Post, sendUrl);
PrepareHttpRequest(request, httpOptions);
// TODO: Use a custom stream implementation over the ReadOnlyBuffer<byte>
request.Content = new ByteArrayContent(buffer.ToArray());
var response = await httpClient.SendAsync(request, transportCts.Token);
response.EnsureSuccessStatusCode();
logger.SentSuccessfully();
}
else if (result.IsCompleted)
{
break;
}
else
{
logger.NoMessages();
}
}
finally
{
application.Input.AdvanceTo(buffer.End);
}
}
}
catch (OperationCanceledException)
{
logger.SendCanceled();
}
catch (Exception ex)
{
logger.ErrorSending(sendUrl, ex);
throw;
}
finally
{
// Make sure the poll loop is terminated
transportCts.Cancel();
}
logger.SendStopped();
}
public DefaultTransportFactory(TransportType requestedTransportType, ILoggerFactory loggerFactory, HttpClient httpClient, HttpOptions httpOptions)
{
if (requestedTransportType <= 0 || requestedTransportType > TransportType.All)
{
throw new ArgumentOutOfRangeException(nameof(requestedTransportType));
}
if (httpClient == null && requestedTransportType != TransportType.WebSockets)
{
throw new ArgumentNullException(nameof(httpClient));
}
_requestedTransportType = requestedTransportType;
_loggerFactory = loggerFactory;
_httpClient = httpClient;
_httpOptions = httpOptions;
}
public void HandleFailedEventSubmission_ByDefault_NoHandlerAssigned()
{
var sut = new HttpOptions(DsnSamples.Valid.SentryUri);
Assert.Null(sut.HandleFailedEventSubmission);
}
internal static void DisplayFunctionsInfo(ICollection <FunctionDescriptor> functions, HttpOptions httpOptions, Uri baseUri)
{
var allValidFunctions = functions.Where(f => !f.Metadata.IsDisabled());
if (allValidFunctions.Any())
{
ColoredConsole
.WriteLine()
.WriteLine(DarkYellow("Functions:"))
.WriteLine();
}
DisplayHttpFunctions(functions, httpOptions, baseUri);
DisplayNonHttpFunctionsInfo(functions);
DisplayDisabledFunctions(functions);
}
public LongPollingTransport(HttpClient httpClient, HttpOptions httpOptions, ILoggerFactory loggerFactory)
{
_httpClient = httpClient;
_httpOptions = httpOptions;
_logger = (loggerFactory ?? NullLoggerFactory.Instance).CreateLogger <LongPollingTransport>();
}
private static void DisplayHttpFunctions(ICollection <FunctionDescriptor> functions, HttpOptions httpOptions, Uri baseUri)
{
var httpFunctions = functions.Where(f => f.Metadata.IsHttpFunction() && !f.Metadata.IsDisabled());
foreach (var function in httpFunctions)
{
var binding = function.Metadata.Bindings.FirstOrDefault(b => b.Type != null && b.Type.Equals("httpTrigger", StringComparison.OrdinalIgnoreCase));
var httpRoute = binding?.Raw?.GetValue("route", StringComparison.OrdinalIgnoreCase)?.ToString();
httpRoute = httpRoute ?? function.Name;
string[] methods = null;
var methodsRaw = binding?.Raw?.GetValue("methods", StringComparison.OrdinalIgnoreCase)?.ToString();
if (string.IsNullOrEmpty(methodsRaw) == false)
{
methods = methodsRaw.Split(',');
}
string hostRoutePrefix = "";
if (!function.Metadata.IsProxy())
{
hostRoutePrefix = httpOptions.RoutePrefix ?? "api/";
hostRoutePrefix = string.IsNullOrEmpty(hostRoutePrefix) || hostRoutePrefix.EndsWith("/")
? hostRoutePrefix
: $"{hostRoutePrefix}/";
}
var functionMethods = methods != null ? $"{CleanAndFormatHttpMethods(string.Join(",", methods))}" : null;
var url = $"{baseUri.ToString().Replace("0.0.0.0", "localhost")}{hostRoutePrefix}{httpRoute}";
ColoredConsole
.WriteLine($"\t{HttpFunctionNameColor($"{function.Name}:")} {HttpFunctionUrlColor(functionMethods)} {HttpFunctionUrlColor(url)}")
.WriteLine();
}
}
public void RequestBodyCompressionLevel_ByDefault_Optimal()
{
var sut = new HttpOptions(DsnSamples.Valid.SentryUri);
Assert.Equal(CompressionLevel.Optimal, sut.RequestBodyCompressionLevel);
}
public HttpContent(HttpOptions options) : base(options)
{
}
public Promise<IHttpResponse, Error> Get(Uri url, Dictionary<string, string> headers, HttpOptions options = null)
{
return Request("GET", url, headers, null, options);
}
/// <summary>
/// Uses HTTP Protocol and accepts HTTP connections with Twino MVC Architecture
/// </summary>
public static ITwinoServer UseMvc(this ITwinoServer server, TwinoMvc mvc)
{
return(UseMvc(server, mvc, HttpOptions.CreateDefault()));
}
public static void UseSequin(this IAppBuilder app, HttpOptions options)
{
app.UseSequin(options, new ResponseMiddleware[0]);
}
public HttpConnection(Uri url, TransportType transportType, ILoggerFactory loggerFactory, HttpOptions httpOptions)
{
Url = url ?? throw new ArgumentNullException(nameof(url));
_loggerFactory = loggerFactory ?? NullLoggerFactory.Instance;
_logger = _loggerFactory.CreateLogger <HttpConnection>();
_httpOptions = httpOptions;
_requestedTransportType = transportType;
if (_requestedTransportType != TransportType.WebSockets)
{
_httpClient = httpOptions?.HttpMessageHandler == null ? new HttpClient() : new HttpClient(httpOptions.HttpMessageHandler);
_httpClient.Timeout = HttpClientTimeout;
}
_transportFactory = new DefaultTransportFactory(transportType, _loggerFactory, _httpClient, httpOptions);
}
public async Task UseHttp_GivenStaticOptions_ThenValid()
{
var options = new HttpOptions
{
ConnectionName = "connection-name-test",
Scheme = "http",
Host = "127.0.0.1",
Port = 8080,
Method = "POST",
};
var mockBusHandle = new Mock <BusHandle>(MockBehavior.Strict);
var mockBusControl = new Mock <IBusControl>(MockBehavior.Strict);
var mockHttpBusFactory = new Mock <IBusFactory <IHttpBusFactoryConfigurator> >(MockBehavior.Strict);
var mockHttpBusFactoryConfigurator = new Mock <IHttpBusFactoryConfigurator>(MockBehavior.Strict);
var mockHttpHost = new Mock <IHttpHost>(MockBehavior.Strict);
mockBusControl
.Setup(_ => _.StartAsync(It.IsAny <CancellationToken>()))
.ReturnsAsync(mockBusHandle.Object)
.Verifiable();
mockBusControl
.Setup(_ => _.StopAsync(It.IsAny <CancellationToken>()))
.Returns(Task.CompletedTask)
.Verifiable();
mockHttpBusFactory
.Setup(_ => _.Create(It.IsAny <Action <IHttpBusFactoryConfigurator> >()))
.Callback((Action <IHttpBusFactoryConfigurator> configure) => configure(mockHttpBusFactoryConfigurator.Object))
.Returns(mockBusControl.Object)
.Verifiable();
mockHttpBusFactoryConfigurator
.Setup(_ => _.Host(It.IsAny <HttpHostSettings>()))
.Callback((HttpHostSettings settings) =>
{
Assert.Equal(options.Scheme, settings.Scheme);
Assert.Equal(options.Host, settings.Host);
Assert.Equal(options.Port, settings.Port);
Assert.Same(HttpMethod.Post, settings.Method);
Assert.Equal($"{options.Host}:{options.Port}", settings.Description);
})
.Returns(mockHttpHost.Object)
.Verifiable();
var services = new ServiceCollection();
services.AddSingleton(mockHttpBusFactory.Object);
services.AddLogging(builder =>
{
builder.SetMinimumLevel(LogLevel.Trace);
builder.AddXUnit(_output);
});
services.AddMassTransit(builder =>
{
builder.UseHttp(options);
});
using (var serviceProvider = services.BuildServiceProvider())
{
var busManager = serviceProvider.GetRequiredService <IBusManager>();
await busManager.StartAsync(CancellationToken.None).ConfigureAwait(false);
var bus = busManager.GetBus(options.ConnectionName);
Assert.NotNull(bus);
await busManager.StopAsync(CancellationToken.None).ConfigureAwait(false);
}
mockHttpHost.Verify();
mockHttpBusFactoryConfigurator.Verify();
mockHttpBusFactory.Verify();
mockBusControl.Verify();
mockBusHandle.Verify();
}
private void InitializeHttpFunctions(IEnumerable <FunctionDescriptor> functions, HttpOptions httpOptions)
{
_router.ClearRoutes();
// TODO: FACAVAL Instantiation of the ScriptRouteHandler should be cleaned up
WebJobsRouteBuilder routesBuilder = _router.CreateBuilder(new ScriptRouteHandler(_loggerFactory, _host, _environment, false), httpOptions.RoutePrefix);
// Proxies do not honor the route prefix defined in host.json
WebJobsRouteBuilder proxiesRoutesBuilder = _router.CreateBuilder(new ScriptRouteHandler(_loggerFactory, _host, _environment, true), routePrefix: null);
foreach (var function in functions)
{
var httpTrigger = function.GetTriggerAttributeOrNull <HttpTriggerAttribute>();
if (httpTrigger != null)
{
var constraints = new RouteValueDictionary();
if (httpTrigger.Methods != null)
{
constraints.Add("httpMethod", new HttpMethodRouteConstraint(httpTrigger.Methods));
}
string route = httpTrigger.Route;
if (string.IsNullOrEmpty(route) && !function.Metadata.IsProxy)
{
route = function.Name;
}
WebJobsRouteBuilder builder = function.Metadata.IsProxy ? proxiesRoutesBuilder : routesBuilder;
builder.MapFunctionRoute(function.Metadata.Name, route, constraints, function.Metadata.Name);
}
}
IRouter proxyRouter = null;
IRouter functionRouter = null;
if (proxiesRoutesBuilder.Count > 0)
{
proxyRouter = proxiesRoutesBuilder.Build();
}
if (routesBuilder.Count > 0)
{
functionRouter = routesBuilder.Build();
}
_router.AddFunctionRoutes(functionRouter, proxyRouter);
}
public void SentryUri_ValidUrl_StoredInProperty()
{
var sut = new HttpOptions(DsnSamples.Valid.SentryUri);
Assert.Same(DsnSamples.Valid.SentryUri, sut.SentryUri);
}
public SnsHelper(HttpOptions httpOption)
{
HttpOption = httpOption;
_currentUser = new UserEntity();
_currentBbsUser = new UserEntity();
}
/// <summary>
/// Uses WebSocket Protocol and accepts HTTP connections which comes with "Upgrade: websocket" header data
/// </summary>
public static IHorseServer UseWebSockets(this IHorseServer server,
IProtocolConnectionHandler <WsServerSocket, WebSocketMessage> handler)
{
return(UseWebSockets(server, handler, HttpOptions.CreateDefault()));
}
public Promise<IHttpResponse, Error> Post(Uri url, byte[] postData, Dictionary<string, string> headers, HttpOptions options = null)
{
return Request("POST", url, headers, postData, options);
}
/// <summary>
/// Uses WebSocket Protocol and accepts HTTP connections which comes with "Upgrade: websocket" header data
/// </summary>
public static IHorseServer UseWebSockets(this IHorseServer server,
WebSocketMessageRecievedHandler handlerAction,
HttpOptions options)
{
return(UseWebSockets(server, new MethodWebSocketConnectionHandler(handlerAction), options));
}
public HttpWebRequest Build(HttpOptions options)
{
var result = (HttpWebRequest) WebRequest.Create(options.BaseUri);
options.Configure(result);
return result;
}
public HttpGet(HttpOptions options) : base(options) { }
