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