public MusicStoreBootStrap ConfigureRoute() { // List of delegating handlers. DelegatingHandler[] handlers = new DelegatingHandler[] { new AdminAuthorizationMessageHandler(new AdminUserQuery()) }; // Create a message handler chain with an end-point. var routeHandlers = HttpClientFactory.CreatePipeline( new HttpControllerDispatcher(httpConfiguration), handlers); httpConfiguration.Routes.MapHttpRoute( name: "AdminRoutes", routeTemplate: "api/AdminUser/{user}", defaults: new { controller = "AdminUser", user = RouteParameter.Optional } , constraints: null , handler: routeHandlers); httpConfiguration.Routes.MapHttpRoute( name: "Inventory", routeTemplate: "api/Inventory/{id}", defaults: new { controller = "Inventory", id = RouteParameter.Optional } , constraints: null , handler: routeHandlers); httpConfiguration.Routes.MapHttpRoute( name: "ActionApi", routeTemplate: "api/{controller}/{action}/{id}", defaults: new { controller = "Product", id = RouteParameter.Optional }); httpConfiguration.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { controller = "Product", id = RouteParameter.Optional }); httpConfiguration.Formatters.JsonFormatter.SerializerSettings.ContractResolver = new CamelCasePropertyNamesContractResolver(); return this; }
public DelegatingHandler CreateHandler(HttpConfiguration httpConfig, DelegatingHandler innerHandler = null) { return new CorsMessageHandler(this, httpConfig) { InnerHandler = innerHandler }; }
public static void Register(HttpConfiguration config) { // Web API configuration and services config.MessageHandlers.Add(new CustomHeaderHandler()); // Web API routes config.MapHttpAttributeRoutes(); config.Routes.MapHttpRoute( name: "DefaultApi", routeTemplate: "api/{controller}/{id}", defaults: new { id = RouteParameter.Optional } ); var handlers = new DelegatingHandler[] { new PreRouteMessageHandler() }; var routeHandlers = HttpClientFactory.CreatePipeline(new HttpControllerDispatcher(config), handlers); config.Routes.MapHttpRoute( name: "Route2", routeTemplate: "api1/{controller}/{id}", defaults: new { id = RouteParameter.Optional }, constraints: null, handler: routeHandlers ); config.MessageHandlers.Add(new MethodOverrideHandler()); }
internal async Task<dynamic> PostForm( IEnumerable<KeyValuePair<string, string>> formParameters, string path, DelegatingHandler[] handlers, IEnumerable<KeyValuePair<string, string>> headerParameters = null, bool shouldRetry = true) { using (var client = HttpClientFactory.Create(handlers == null ? new DelegatingHandler[] { new UserAgentHandler() } : handlers.ToArray())) { var uri = _baseAddress + path; var httpResponse = await client.PostAsync(uri, new FormUrlEncodedContent(formParameters)); try { return await HandleResponse(httpResponse); } catch (UnauthorizedException) { if (shouldRetry) { _credentials.ResetAccessToken(); using (var retryClient = HttpClientFactory.Create(await GetHandlers(headerParameters))) { httpResponse = await retryClient.PostAsync(uri, new FormUrlEncodedContent(formParameters)); return await HandleResponse(httpResponse); } } throw; } } }
private void CreateEncryptedRoute(HttpConfiguration configuration) { var section = (NameValueCollection)ConfigurationManager.GetSection("Api2CryptoGraphySettings"); if (section == null) { throw new ApplicationException("Config section 'RestfulWebService' has not been set."); } // arrange. var settings = new CryptoGraphySettings(section); var cryptoHandler = new ServerCryptoHandler(settings.SecretKey, settings.InitialVector, settings.HashKey); var injection = new DelegatingHandler[] { new ServerMessageDumper(), cryptoHandler }; // dump decrypted request & plain response. var handler = HttpClientFactory.CreatePipeline(new HttpControllerDispatcher(configuration), injection); // register encrypted HTTP route. configuration.Routes.MapHttpRoute("Encrypted Route", "api2/{controller}/{action}", null, null, handler); // register timestamp as a route. var timestampProvider = new DefaultTimestampProvider(TimeSpan.FromMinutes(15)) as ITimestampProvider<string>; var timestampHandler = new HttpTimestampHandler<string>(timestampProvider); configuration.Routes.MapHttpRoute("Timestamp Route", "api3/!timestamp!/get", null, null, timestampHandler); // register global timestamp service, it should align with encrypted HTTP route or will not work. configuration.MessageHandlers.Add(new HttpTimestampHandler<string>(configuration, "api2/!timestamp!/get", timestampProvider)); }
public MessageHandlerTracer(DelegatingHandler innerHandler, ITraceWriter traceWriter) { Contract.Assert(innerHandler != null); Contract.Assert(traceWriter != null); _innerHandler = innerHandler; _traceWriter = traceWriter; }
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; } }
/// <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) : base(innerHandler) { if (retryPolicy == null) { throw new ArgumentNullException("retryPolicy"); } RetryPolicy = retryPolicy; }
protected override BatchServiceClient CreateBatchRestClient(string url, string accountName, string key, DelegatingHandler handler = default(DelegatingHandler)) { // Add HTTP recorder to the BatchRestClient HttpMockServer mockServer = HttpMockServer.CreateInstance(); mockServer.InnerHandler = new HttpClientHandler(); BatchServiceClient restClient = base.CreateBatchRestClient(url, accountName, key, mockServer); return restClient; }
private void RegisterEncryptedRoute(HttpConfiguration configuration, ITimestampProvider<string> timestampProvider) { // arrange. var cryptoHandler = new ServerCryptoHandler("secretKeyPassword", "initialVectorPassword", "hashKeyString", timestampProvider); var injection = new DelegatingHandler[] { new ServerMessageDumper(), cryptoHandler, new ServerMessageDumper() }; var handler = HttpClientFactory.CreatePipeline(new HttpControllerDispatcher(configuration), injection); // register encrypted HTTP route. configuration.Routes.MapHttpRoute("Encrypted API", "api2/{controller}/{action}", null, null, handler); }
/// <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 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 BasicAuthenticationHandler(DelegatingHandler innerChannel, IUserValidation userValidation, string realm) : base(innerChannel) { if (userValidation == null) throw new ArgumentNullException("userValidation"); if (string.IsNullOrEmpty(realm)) throw new ArgumentNullException("realm"); this.userValidation = userValidation; this.realm = realm; }
public HttpResponseMessage ExecuteRequest(DelegatingHandler testTarget, HttpRequestMessage requestMessage) { testTarget.InnerHandler = new OKHandler(); InnerHandler = testTarget; var requestTask = SendAsync(requestMessage, new CancellationToken()); while (!requestTask.IsCompleted) { } return requestTask.Result; }
/// <summary> /// 获得MyHttpServer牵头的HttpMessageHandler链 /// </summary> /// <param name="handler"></param> /// <returns></returns> private IEnumerable<string> GetHandlerChain(DelegatingHandler handler) { yield return handler.GetType().Name; while (null != handler.InnerHandler) { yield return handler.InnerHandler.GetType().Name; handler = handler.InnerHandler as DelegatingHandler; if (null == handler) { break; } } }
static void Main(string[] args) { var baseAddress = "http://localhost:8080"; HttpSelfHostConfiguration config = new HttpSelfHostConfiguration(baseAddress); // config.MessageHandlers.Add(new ProgressMessageHandler() { }); // Web API 路由 config.MapHttpAttributeRoutes(); //全局允许CROS // config.EnableCors();//启用跨域 config.Routes.MapHttpRoute ( name: "DefaultApi", routeTemplate: "api/{controller}/{action}/{id}", defaults: new { id = RouteParameter.Optional } ); config.MaxConcurrentRequests = 1000; var handlers = new DelegatingHandler[] { new PassiveAuthenticationMessageHandler(), new HttpServer() }; var routeHandlers = HttpClientFactory.CreatePipeline(new HttpControllerDispatcher(config), handlers); config.Routes.MapHttpRoute( name: "CustomerRouter", routeTemplate: "MyAPI/{Controller}/{Action}/Id", defaults: new { Id = RouteParameter.Optional }, constraints: null, handler: routeHandlers ); HttpSelfHostServer server = new HttpSelfHostServer(config); server.OpenAsync(); TaskManager.Instance.Initialize(); TaskManager.Instance.Start(); DefaultHttpBatchHandler batchHandler = new DefaultHttpBatchHandler(server); Console.WriteLine("Server http://localhost:8080 Open now ....at {0}..", server.Configuration.VirtualPathRoot); config.EnsureInitialized(); foreach (var route in config.Routes) { System.Diagnostics.Debug.WriteLine(route); } Console.ReadLine(); }
internal HttpServerWrapper(string baseAddress) { var configuration = new HttpSelfHostConfiguration(baseAddress); // arrange. var injection = new DelegatingHandler[] { new ServerMessageDumper() }; var handler = HttpClientFactory.CreatePipeline(new HttpControllerDispatcher(configuration), injection); // register HTTP route. configuration.Routes.MapHttpRoute("API Default", "api/{controller}/{action}", null, null, handler); // startup local HTTP server. this.inner = new HttpSelfHostServer(configuration); this.inner.OpenAsync().Wait(); this.configuration = configuration; }
public void SuppressHostPrincipal_InsertsSuppressHostPrincipalMessageHandler() { // Arrange DelegatingHandler existingHandler = new Mock <DelegatingHandler>(MockBehavior.Strict).Object; using (HttpConfiguration configuration = new HttpConfiguration()) { configuration.MessageHandlers.Add(existingHandler); // Act configuration.SuppressHostPrincipal(); // Assert Assert.Equal(2, configuration.MessageHandlers.Count); DelegatingHandler firstHandler = configuration.MessageHandlers[0]; Assert.IsType <SuppressHostPrincipalMessageHandler>(firstHandler); } }
/// <summary> /// Creates an <see cref="HttpClient"/> /// </summary> /// <param name="primaryHandlers">The handlers that will be added to the top of the chain.</param> public virtual HttpClient CreateHttpClient(params DelegatingHandler[] primaryHandlers) { var delegateHandlers = new DelegatingHandler[] { new AuthenticationHandler(cloudCredentials: credentials), new UserAgentHandler(headerValues: headerValues), new TracingHandler(), new RetryHandler(), }; var pipeline = (HttpMessageHandler)(new HttpClientHandler()); var reversedHandlers = primaryHandlers.CoalesceEnumerable().Concat(delegateHandlers).ToArray().Reverse(); foreach (var handler in reversedHandlers) { handler.InnerHandler = pipeline; pipeline = handler; } return new HttpClient(pipeline); }
public void CreatePipeline_WiresUpHandlers(int maxHandlerCount) { // Arrange List <DelegatingHandler> handlers = new List <DelegatingHandler>(); for (int handlerCount = 0; handlerCount < maxHandlerCount; handlerCount++) { handlers.Add(new MockDelegatingHandler()); } HttpClientHandler innerHandler = new HttpClientHandler(); // Act DelegatingHandler pipeline = HttpClientFactory.CreatePipeline(innerHandler, handlers) as DelegatingHandler; // Assert for (int index = 0; index < handlers.Count - 1; index++) { Assert.Same(handlers[index], pipeline); pipeline = pipeline.InnerHandler as DelegatingHandler; } Assert.Same(innerHandler, pipeline.InnerHandler); }
/// <summary> /// Creates an instance of an <see cref="HttpMessageHandler"/> using the HTTP message handlers /// provided in the constructor. /// </summary> /// <param name="innerChannel">The inner channel represents the destination of the HTTP message channel.</param> /// <returns>The HTTP message channel.</returns> protected virtual HttpMessageHandler OnCreate(HttpMessageHandler innerChannel) { if (innerChannel == null) { throw FxTrace.Exception.ArgumentNull("innerChannel"); } // Get handlers either by constructing types or by calling Func IEnumerable<DelegatingHandler> handlerInstances = null; try { if (_handlerFunc != null) { handlerInstances = _handlerFunc.Invoke(); if (handlerInstances != null) { foreach (DelegatingHandler handler in handlerInstances) { if (handler == null) { throw FxTrace.Exception.Argument("handlers", SR.Format(SR.DelegatingHandlerArrayFromFuncContainsNullItem, s_delegatingHandlerType.Name, GetFuncDetails(_handlerFunc))); } } } } else if (_handlerCtors != null) { DelegatingHandler[] instances = new DelegatingHandler[_handlerCtors.Length]; for (int cnt = 0; cnt < _handlerCtors.Length; cnt++) { instances[cnt] = (DelegatingHandler)_handlerCtors[cnt].Invoke(Array.Empty<Type>()); } handlerInstances = instances; } } catch (TargetInvocationException targetInvocationException) { throw FxTrace.Exception.AsError(targetInvocationException); } // Wire handlers up HttpMessageHandler pipeline = innerChannel; if (handlerInstances != null) { foreach (DelegatingHandler handler in handlerInstances) { if (handler.InnerHandler != null) { throw FxTrace.Exception.Argument("handlers", SR.Format(SR.DelegatingHandlerArrayHasNonNullInnerHandler, s_delegatingHandlerType.Name, "InnerHandler", handler.GetType().Name)); } handler.InnerHandler = pipeline; pipeline = handler; } } return pipeline; }
/// <summary> /// Get an instance of the AlertsClient class that uses the handler while initiating web requests. /// </summary> /// <param name="handler">the handler</param> public override AutoscaleClient WithHandler(DelegatingHandler handler) { return WithHandler(new AutoscaleClient(), handler); }
protected virtual BatchServiceClient CreateBatchRestClient(string url, string accountName, string key, DelegatingHandler handler = default(DelegatingHandler)) { ServiceClientCredentials credentials = new Microsoft.Azure.Batch.Protocol.BatchSharedKeyCredential(accountName, key); BatchServiceClient restClient = handler == null ? new BatchServiceClient(new Uri(url), credentials) : new BatchServiceClient(new Uri(url), credentials, handler); restClient.HttpClient.DefaultRequestHeaders.UserAgent.Add(Microsoft.WindowsAzure.Commands.Common.AzurePowerShell.UserAgentValue); restClient.SetRetryPolicy(null); //Force there to be no retries restClient.HttpClient.Timeout = Timeout.InfiniteTimeSpan; //Client side timeout will be set per-request return restClient; }
public TraceMessageHandler(DelegatingHandler innerChannel) : base(innerChannel) { }
public static Task<HttpResponseMessage> InvokeMessageHandler(HttpRequestMessage requestMessage, DelegatingHandler handler, CancellationToken cancellationToken=default(CancellationToken)) { handler.InnerHandler=new DummyHandler(); var messageInvoker = new HttpMessageInvoker(handler); return messageInvoker.SendAsync(requestMessage, cancellationToken); }
public MediaServicesManagementClient WithHandler(DelegatingHandler handler) { return (MediaServicesManagementClient)WithHandler(new MediaServicesManagementClient(), handler); }
public override ApplicationGatewayManagementClient WithHandler(DelegatingHandler handler) { return (ApplicationGatewayManagementClient)WithHandler(new ApplicationGatewayManagementClient(), handler); }
private static DelegatingHandler[] AddJwtTokenRefresher(DelegatingHandler[] srcHandlers, MicrosoftAppCredentials credentials) { var handlers = new List<DelegatingHandler>(srcHandlers); handlers.Add(new JwtTokenRefresher(credentials)); return handlers.ToArray(); }
/// <summary> /// Generate a Resource Management client from the test base to use for managing resource groups. /// </summary> /// <returns>Resource Management client</returns> public static ResourceManagementClient GetResourceClient(DelegatingHandler handler) { return TestBase.GetServiceClient<ResourceManagementClient>(new CSMTestEnvironmentFactory()).WithHandler(handler); }
public override BatchManagementClient WithHandler(DelegatingHandler handler) { return (BatchManagementClient)WithHandler(new BatchManagementClient(), handler); }
public override StorageManagementClient WithHandler(DelegatingHandler handler) { return (StorageManagementClient)WithHandler(new StorageManagementClient(), handler); }
public static async Task<int> HttpInvoke(Uri uri, TokenCacheInfo cacheInfo, string verb, DelegatingHandler handler, HttpContent content) { using (var client = new HttpClient(handler)) { client.DefaultRequestHeaders.Add("Authorization", cacheInfo.CreateAuthorizationHeader()); client.DefaultRequestHeaders.Add("User-Agent", Constants.UserAgent.Value); client.DefaultRequestHeaders.Add("Accept", Constants.JsonContentType); if (Utils.IsRdfe(uri)) { client.DefaultRequestHeaders.Add("x-ms-version", "2013-10-01"); } client.DefaultRequestHeaders.Add("x-ms-request-id", Guid.NewGuid().ToString()); HttpResponseMessage response = null; if (String.Equals(verb, "get", StringComparison.OrdinalIgnoreCase)) { response = await client.GetAsync(uri); } else if (String.Equals(verb, "delete", StringComparison.OrdinalIgnoreCase)) { response = await client.DeleteAsync(uri); } else if (String.Equals(verb, "post", StringComparison.OrdinalIgnoreCase)) { response = await client.PostAsync(uri, content); } else if (String.Equals(verb, "put", StringComparison.OrdinalIgnoreCase)) { response = await client.PutAsync(uri, content); } else if (String.Equals(verb, "patch", StringComparison.OrdinalIgnoreCase)) { using (var message = new HttpRequestMessage(new HttpMethod("PATCH"), uri)) { message.Content = content; response = await client.SendAsync(message).ConfigureAwait(false); } } else { throw new InvalidOperationException(String.Format("Invalid http verb {0}!", verb)); } using (response) { if (response.IsSuccessStatusCode) { return 0; } return (-1) * (int)response.StatusCode; } } }