/// <summary>
 /// Initializes a new instance.
 /// </summary>
 public LoggerHttpMiddleware(
     FluentHttpMiddlewareDelegate next,
     FluentHttpMiddlewareClientContext context,
     LoggerHttpMiddlewareOptions options,
     ILoggerFactory loggerFactory
     )
 {
     _next    = next;
     _options = options;
     _logger  = loggerFactory.CreateLogger($"{typeof(LoggerHttpMiddleware).Namespace}.{context.Identifier}.Logger");
 }
 /// <summary>
 /// Initializes a new instance.
 /// </summary>
 public ResponseCacheHttpMiddleware(
     FluentHttpMiddlewareDelegate next,
     FluentHttpMiddlewareClientContext context,
     ResponseCacheHttpMiddlewareOptions options,
     ILoggerFactory loggerFactory,
     IResponseCacheService service
     )
 {
     _next    = next;
     _options = options;
     _logger  = loggerFactory.CreateLogger($"{typeof(ResponseCacheHttpMiddleware).Namespace}.{context.Identifier}.ResponseCache");
     _service = service;
 }
Ejemplo n.º 3
0
        /// <summary>
        /// Build configured <see cref="IFluentHttpMiddlewareRunner"/>.
        /// </summary>
        /// <param name="httpClient">HTTP client which consumes this.</param>
        public IFluentHttpMiddlewareRunner Build(IFluentHttpClient httpClient)
        {
            var middleware = _middleware.ToList();

            middleware.Add(new FluentHttpMiddlewareConfig(typeof(ActionExecuteMiddleware)));

            var clientContext = new FluentHttpMiddlewareClientContext(httpClient.Identifier);

            IFluentHttpMiddleware previous = null;

            for (int i = middleware.Count; i-- > 0;)
            {
                var pipe    = middleware[i];
                var isLast  = middleware.Count - 1 == i;
                var isFirst = i == 0;

                object[] ctor;
                if (!isLast)
                {
                    FluentHttpMiddlewareDelegate next = previous.Invoke;
                    if (pipe.Args == null)
                    {
                        ctor = new object[] { next, clientContext }
                    }
                    ;
                    else
                    {
                        const int additionalCtorArgs = 2;
                        ctor    = new object[pipe.Args.Length + additionalCtorArgs];
                        ctor[0] = next;
                        ctor[1] = clientContext;
                        Array.Copy(pipe.Args, 0, ctor, additionalCtorArgs, pipe.Args.Length);
                    }
                }
                else
                {
                    ctor = new object[] { }
                };
                var instance = (IFluentHttpMiddleware)ActivatorUtilities.CreateInstance(_serviceProvider, pipe.Type, ctor);

                if (isFirst)
                {
                    return(new FluentHttpMiddlewareRunner(instance));
                }
                previous = instance;
            }
            throw new InvalidOperationException("Middleware wasn't build correctly.");
        }
    }
        /// <summary>
        /// Initializes a new instance.
        /// </summary>
        public TimerHttpMiddleware(
            FluentHttpMiddlewareDelegate next,
            FluentHttpMiddlewareClientContext context,
            TimerHttpMiddlewareOptions options,
            ILoggerFactory loggerFactory
            )
        {
            _next    = next;
            _options = options;
            _logger  = loggerFactory.CreateLogger($"{typeof(TimerHttpMiddleware).Namespace}.{context.Identifier}.Timer");

            if (_options.WarnThreshold <= TimeSpan.Zero)
            {
                throw new ArgumentException($"{nameof(_options.WarnThreshold)} must be greater than Zero.");
            }
        }
 public TestHttpMiddleware(FluentHttpMiddlewareDelegate next, FluentHttpMiddlewareClientContext _context)
 {
     _next = next;
 }