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