/// <summary> /// Initializes a new instance of the <see cref="RetryDelegatingHandler"/> class. /// </summary> /// <param name="retryPolicy">Retry policy to use.</param> /// <param name="innerHandler">Inner http handler.</param> public RetryDelegatingHandler(RetryPolicy retryPolicy, DelegatingHandler innerHandler) : this(innerHandler) { if (retryPolicy == null) { throw new ArgumentNullException("retryPolicy"); } RetryPolicy = retryPolicy; }
/// <summary> /// Gets a client instance suitable for faking calls to the RP. /// </summary> /// <param name="handler"></param> /// <returns></returns> private static DataFactoryManagementClient GetFakeClient(DelegatingHandler handler) { string fakeSubscriptionId = Guid.NewGuid().ToString("D"); string fakePassword = "******"; var baseUri = new Uri("https://localhost"); return(new DataFactoryManagementClient( new TokenCloudCredentials(fakeSubscriptionId, fakePassword), baseUri).WithHandler(handler)); }
internal static IServiceCollection ReplaceHttpMessageHandlerFor <TClient>( this IServiceCollection services, DelegatingHandler fakeHttpMessageHandler) where TClient : class { services .AddHttpClient <TClient>() .ConfigurePrimaryHttpMessageHandler(() => fakeHttpMessageHandler); return(services); }
public void CreateClient_WithInnerHandlerReference() { DelegatingHandler[] handlers = new DelegatingHandler[1]; handlers[0] = new RetryHandler(this.testHttpMessageHandler); // Creation should ignore the InnerHandler on RetryHandler HttpClient client = GraphClientFactory.Create(handlers: handlers); Assert.NotNull(client); Assert.IsType <HttpClientHandler>(handlers[0].InnerHandler); }
private static ResourceManagementClient CreateResourceManagementClient(DelegatingHandler handler) { string subscriptionId = Guid.NewGuid().ToString(); var token = new TokenCredentials(subscriptionId, "foo"); return(new ResourceManagementClient(token, handler) { SubscriptionId = subscriptionId }); }
public InvocationResult GetInvocationResultFor(object result, object inboundPayload) { if (InvokerHandlerMethod != null) { return(new InvocationResult(result, null, InvokerHandlerMethod.Method.ReturnType, InvokerHandlerMethod.Bean, InvokerHandlerMethod.Method)); } else { return(DelegatingHandler.GetInvocationResultFor(result, inboundPayload)); } }
private AuthClient GetTestClient(IAuthenticator authenticator, string endpoint, HttpStatusCode httpStatusCode, object httpPayload = null) { var host = "http://fakeEndpoint"; var clientHandler = new HttpClientHandler(); var delegatingHandlers = new DelegatingHandler[] { FakeResponseHandler.Create(httpStatusCode, host + "/" + endpoint, httpPayload) }; return(new AuthClient(authenticator, host, clientHandler, delegatingHandlers)); }
/// <summary> /// Initializes a new instance of the <see cref="RetryDelegatingHandler"/> class. Sets /// the default retry policty base on Exponential Backoff. /// </summary> /// <param name="innerHandler">Inner http handler.</param> public RetryDelegatingHandler(DelegatingHandler innerHandler) : base(innerHandler) { var retryStrategy = new ExponentialBackoffRetryStrategy( DefaultNumberOfAttempts, DefaultMinBackoff, DefaultMaxBackoff, DefaultBackoffDelta); RetryPolicy = new RetryPolicy <HttpStatusCodeErrorDetectionStrategy>(retryStrategy); }
public Twitch(IConfigurationRoot config) { // Build handler with RateLimit DelegatingHandler handler = TimeLimiter.GetFromMaxCountByInterval(750, TimeSpan.FromMinutes(1)).AsDelegatingHandler(); twitch = new HttpClient(handler); // Set headers for the twitch api request twitch.DefaultRequestHeaders.Add("Client-ID", config.GetApiKey("Twitch")); twitch.DefaultRequestHeaders.Add("Authorization", config.GetApiKey("Twitch_OAuth")); configuration = config; }
public HttpResponseMessage ExecuteRequest(DelegatingHandler testTarget, HttpRequestMessage requestMessage) { testTarget.InnerHandler = new OKHandler(); InnerHandler = testTarget; var requestTask = SendAsync(requestMessage, new CancellationToken()); requestTask.Wait(5000); // 5 second timeout - tests should be quicker than this, but better than infinite for now return(requestTask.Result); }
public CalendarService(IOptions <CalendarOptions> options, DelegatingHandler handler) { _options = options.Value; _client = new HttpClient(handler) { BaseAddress = _options.BaseAddress }; _client.DefaultRequestHeaders.Clear(); _client.DefaultRequestHeaders.Add("Accept", "application/json"); }
private IEnumerable <string> GetChains(DelegatingHandler handler) { yield return(handler.GetType().FullName); var innerHander = handler.InnerHandler as DelegatingHandler; if (innerHander != null) { yield return(innerHander.GetType().FullName); } }
/// <inheritdoc /> /// <exception cref="T:System.ArgumentNullException"> /// When the <paramref name="delegatingHandler"/> parameter is <see langword="null"/>. /// </exception> public IHttpClientBuilder AddHandler(DelegatingHandler delegatingHandler) { if (delegatingHandler == null) { throw new ArgumentNullException(nameof(delegatingHandler)); } _httpMessageHandlerBuilder.AddHandler(delegatingHandler); return(this); }
public ApiRouter WithHandler(DelegatingHandler delegatingHandler) { // router -> MessageHandler -> router ->Child Router _MessageHandler = delegatingHandler; _MessageHandler.InnerHandler = this; InnerHandler = _MessageHandler; // This creates a crazy loop. The router has to know when it is re-entered to prevent the cyle. // Current innerhandler is a HttpControllerDispatcher which we aren't using, so throw away :-) return(this); }
public void i_can_append_multiple_delegate_to_not_queued_handler() { DelegatingHandler[] handlers = CreateHandlers(3); DelegatingHandler handlerChain = CreateTopBottomHandler(handlers); DelegatingHandler[] handlersToAppend = CreateHandlers(3, 4); DelegatingHandler toAppend = CreateTopBottomHandler(handlersToAppend); handlerChain.Append(toAppend); Assert.AreEqual(toAppend, handlers.Last().InnerHandler, "handler has not been appended"); }
/// <summary> /// Adds a <see cref="T:System.Net.Http.HttpMessageHandler"/> to the end of the handlers list. /// </summary> /// <param name="handler">Handler.</param> /// <exception cref="T:System.ArgumentNullException"> /// When the <paramref name="handler"/> parameter is <see langword="null"/>. /// </exception> /// <returns>Current builder.</returns> public HttpMessageHandlerBuilder AddHandler(DelegatingHandler handler) { if (handler == null) { throw new ArgumentNullException(nameof(handler)); } AdditionalHandlers.Add(handler); return(this); }
public void i_can_append_multiple_delegate_to_queued_handler() { DelegatingHandler[] handlers = CreateHandlers(3); DelegatingHandler handlerChain = CreateTopBottomHandler(handlers, true); DelegatingHandler[] handlersToAppend = CreateHandlers(3, 4); DelegatingHandler toAppend = CreateTopBottomHandler(handlersToAppend); handlerChain.Append(toAppend); Assert.AreEqual(toAppend, handlers.Last().InnerHandler, "handler has not been appended"); Assert.IsInstanceOf <TestQueueHandler>(handlersToAppend.Last().InnerHandler, "queue has not been appended to appended chain"); }
public MockedHttpServer(DelegatingHandler byPassHandler, string baseAddress, Action <HttpSelfHostConfiguration> setup = null) { var config = new HttpSelfHostConfiguration(baseAddress); config.MessageHandlers.Add(byPassHandler); if (setup != null) { setup(config); } httpSelfHostServer = new HttpSelfHostServer(config); httpSelfHostServer.OpenAsync().Wait(); }
protected async Task <HttpRequestMessage> InvokeAsync(DelegatingHandler handler, HttpRequestMessage request) { var testHandler = new TestDelegatingHandler(); handler.InnerHandler = testHandler; var invoker = new HttpMessageInvoker(handler); await invoker.SendAsync(request, CancellationToken.None); return(testHandler.Request); }
public void Decorator_GetInner_On_MessageHandlerTracer_Returns_DelegatingHandler() { // Arrange DelegatingHandler expectedInner = new Mock <DelegatingHandler>().Object; MessageHandlerTracer productUnderTest = new MessageHandlerTracer(expectedInner, new TestTraceWriter()); // Act DelegatingHandler actualInner = Decorator.GetInner(productUnderTest as DelegatingHandler); // Assert Assert.Same(expectedInner, actualInner); }
public void Inner_Property_On_MessageHandlerTracer_Returns_DelegatingHandler() { // Arrange DelegatingHandler expectedInner = new Mock <DelegatingHandler>().Object; MessageHandlerTracer productUnderTest = new MessageHandlerTracer(expectedInner, new TestTraceWriter()); // Act DelegatingHandler actualInner = productUnderTest.Inner; // Assert Assert.Same(expectedInner, actualInner); }
/// <summary> /// 使用<paramref name="handler"/>作为中间件 /// </summary> /// <param name="httpClient"></param> /// <param name="handler"></param> /// <returns></returns> public static HttpClient Use(this HttpClient httpClient, DelegatingHandler handler) { var handlerFieldInfo = Utils.Reflection.GetFieldInfo <HttpMessageInvoker>(Constants.HttpMessageInvokerHandler, BindingFlags.Instance | BindingFlags.NonPublic); var httpMessageHandler = (HttpMessageHandler)handlerFieldInfo.GetValue(httpClient); handler.InnerHandler = httpMessageHandler; handlerFieldInfo.SetValue(httpClient, handler); return(httpClient); }
public LocationAPI(ISettings settings, DelegatingHandler handler) { var client = new HttpClient(handler) { BaseAddress = settings.ApiBaseAddress }; client.DefaultRequestHeaders.Clear(); client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json")); _client = client; }
private void AddHandlerToChain(DelegatingHandler newHandler) { if (_rootHandler == null) { _rootHandler = newHandler; _leafHandler = newHandler; } else { _leafHandler.InnerHandler = newHandler; _leafHandler = newHandler; } }
private HttpClient CreateTestClient(DelegatingHandler authenticationHandler) { authenticationHandler.InnerHandler = new FakeHttpClientHandler <object>(HttpStatusCode.OK) { AssertAuthorizationHeader = true }; var client = new HttpClient(authenticationHandler) { BaseAddress = new Uri(TestUrl) }; return(client); }
private static HttpClient GetHttpClient() { var clientHandler = new HttpClientHandler { AllowAutoRedirect = false }; DelegatingHandler[] handlers = new DelegatingHandler[] { new RetryMessageHandler(), new LoggingMessageHandler() }; HttpClient client = HttpClientFactory.Create(clientHandler, handlers); var assemblyVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString(); client.DefaultRequestHeaders.UserAgent.Add(new ProductInfoHeaderValue("Microsoft-BotFramework-RealTimeMedia", assemblyVersion)); return(client); }
private IAuthenticator GetTestAuthenticator(HttpStatusCode rpsStatusCode, object rpsPayload) { var authHost = "http://fakeAuthUrl"; var config = new RpsConfig(authHost, "fakeSiteID", "fakeScope", "fakePolicy", new X509Certificate2()); var rpsMessageHandler = new HttpClientHandler(); var rpsDelegatingHandlers = new DelegatingHandler[] { FakeResponseHandler.Create(rpsStatusCode, authHost, rpsPayload) }; return(new RpsAuthenticator(config, rpsMessageHandler, rpsDelegatingHandlers)); }
/// <summary> /// Initializes a new instance of the <see cref="TeamsMiddleware"/> class. This method can be used in /// ASP.Net WebApi projects. /// </summary> /// <param name="credentialProvider">The credential provider.</param> /// <param name="connectorClientRetryPolicy">The connector client retry policy.</param> /// <param name="delegatingHandler">The delegating handler.</param> /// <param name="channelProvider">The channel provider.</param> public TeamsMiddleware( ICredentialProvider credentialProvider, RetryPolicy connectorClientRetryPolicy = null, DelegatingHandler delegatingHandler = null, IChannelProvider channelProvider = null) { this.credentialProvider = credentialProvider; this.connectorClientRetryPolicy = connectorClientRetryPolicy; this.delegatingHandler = delegatingHandler; this.channelProvider = channelProvider; this.credentialHttpClient = delegatingHandler == null ? new HttpClient() : new HttpClient(delegatingHandler); }
private static void CreateMessageHandlerTracers(HttpConfiguration configuration, ITraceWriter traceWriter) { // Insert a tracing handler before each existing message handler (in execution order) int handlerCount = configuration.MessageHandlers.Count; for (int i = 0; i < handlerCount * 2; i += 2) { DelegatingHandler innerHandler = configuration.MessageHandlers[i]; DelegatingHandler handlerTracer = new MessageHandlerTracer(innerHandler, traceWriter); configuration.MessageHandlers.Insert(i + 1, handlerTracer); } configuration.MessageHandlers.Add(new RequestMessageHandlerTracer(traceWriter)); }
private DelegatingHandler WireHttpHandlers() { DelegatingHandler handler = null; #if DEBUG handler = new HttpLoggingHandler(); #endif ////if (DefaultSettings.ThrowExceptionsHttpRequests) ////{ //// handler = new HttpExceptionalHandler(handler); ////} return(handler); }
public override ManagedCacheClient WithHandler(DelegatingHandler handler) { return (ManagedCacheClient)WithHandler(new ManagedCacheClient(), handler); }