Пример #1
0
 /// <summary>
 /// Instance a new Stack Client plugin container.
 /// </summary>
 /// <param name="defaults">Defaults values for queries executed against this client.</param>
 /// <param name="handler">A request handler for this client.</param>
 /// <param name="logger">Event log message dispatcher.</param>
 /// <param name="cache">API Response cache store.</param>
 /// <param name="throttler">Request throttler.</param>
 public StackClientPlugins(IDefaults defaults, IRequestHandler handler, IEventLog logger, IResponseCache cache, IRequestThrottler throttler)
 {
     if (defaults == null)
     {
         throw new ArgumentNullException("defaults");
     }
     if (handler == null)
     {
         throw new ArgumentNullException("handler");
     }
     if (logger == null)
     {
         throw new ArgumentNullException("logger");
     }
     if (cache == null)
     {
         throw new ArgumentNullException("cache");
     }
     if (throttler == null)
     {
         throw new ArgumentNullException("throttler");
     }
     Default        = defaults;
     RequestHandler = handler;
     EventLog       = logger;
     Cache          = cache;
     Throttler      = throttler;
 }
Пример #2
0
 /// <summary>
 /// Instance a new Stack Client plugin container.
 /// </summary>
 /// <param name="defaults">Defaults values for queries executed against this client.</param>
 /// <param name="handler">A request handler for this client.</param>
 /// <param name="logger">Event log message dispatcher.</param>
 /// <param name="cache">API Response cache store.</param>
 /// <param name="throttler">Request throttler.</param>
 public StackClientPlugins(IDefaults defaults, IRequestHandler handler, IEventLog logger, IResponseCache cache, IRequestThrottler throttler)
 {
     if (defaults == null)
     {
         throw new ArgumentNullException("defaults");
     }
     if (handler == null)
     {
         throw new ArgumentNullException("handler");
     }
     if (logger == null)
     {
         throw new ArgumentNullException("logger");
     }
     if (cache == null)
     {
         throw new ArgumentNullException("cache");
     }
     if (throttler == null)
     {
         throw new ArgumentNullException("throttler");
     }
     Default = defaults;
     RequestHandler = handler;
     EventLog = logger;
     Cache = cache;
     Throttler = throttler;
 }
        public async Task <byte[]> ExecuteAsync(IHttpClient httpClient, IResponseCache cache)
        {
            var senderToSend = generateCertificateIfAbsent ? await ObtainCertificate(httpClient, cache) : sender;

            var xml = await GenerateFufXml(httpClient, senderToSend);

            return(transformFromUtf8ToCp1251 ? TransformUtf8ToCp1251Encoding(xml) : xml);
        }
Пример #4
0
        public ExternTestTool(string apiKey, IResponseCache cache, ILifetime lifetime, ILog log)
        {
            this.apiKey   = apiKey;
            this.cache    = cache;
            this.lifetime = lifetime;
            httpClient    = new HttpClientImplementation("https://extern-api.testkontur.ru/test-tools/v1/", apiKey, lifetime, log);

            driveCertificatesReader = new DriveCertificatesReader(lifetime);
        }
Пример #5
0
        /// <summary>
        /// Initializes a new instance of the <see cref="Client"/> class.
        /// </summary>
        /// <param name="key">The key.</param>
        /// <param name="requestTimeout">The requestTimeout.</param>
        /// <param name="bufferTimeout">The buffer timeout.</param>
        /// <param name="cache">The response cache.</param>
        public Client(string key, TimeSpan requestTimeout, TimeSpan bufferTimeout, IResponseCache cache)
        {
            if (string.IsNullOrEmpty(key))
                throw new ArgumentException("Embedly account key cannot be empty", "key");

            Key = key;
            RequestTimeout = requestTimeout;
            BufferTimeout = bufferTimeout;
            Cache = cache;
        }
Пример #6
0
        /// <summary>
        /// Initializes a new instance of the <see cref="Client"/> class.
        /// </summary>
        /// <param name="key">The key.</param>
        /// <param name="requestTimeout">The requestTimeout.</param>
        /// <param name="bufferTimeout">The buffer timeout.</param>
        /// <param name="cache">The response cache.</param>
        public Client(string key, TimeSpan requestTimeout, TimeSpan bufferTimeout, IResponseCache cache)
        {
            if (string.IsNullOrEmpty(key))
            {
                throw new ArgumentException("Embedly account key cannot be empty", "key");
            }

            Key            = key;
            RequestTimeout = requestTimeout;
            BufferTimeout  = bufferTimeout;
            Cache          = cache;
        }
Пример #7
0
        protected BasecampApiBase(string accountId, string username, string password, IResponseCache responseCache)
        {
            Username = username;
            Password = password;
            AccountId = accountId;

            ResponseCache = responseCache;
            Projects = new ProjectsEndpoint(ResponseCache);
            People = new PeopleEndpoint(ResponseCache);
            Todos = new TodosEndpoint(ResponseCache);
            Events = new EventsEndpoint(ResponseCache);
        }
Пример #8
0
        /// <summary>
        /// Initializes a new instance of the
        /// <see cref="T:EasyCaching.ResponseCaching.EasyCachingResponseCachingMiddleware"/> class.
        /// </summary>
        /// <param name="next">Next.</param>
        /// <param name="options">Options.</param>
        /// <param name="cache">Cache.</param>
        /// <param name="loggerFactory">Logger factory.</param>
        /// <param name="policyProvider">Policy provider.</param>
        /// <param name="keyProvider">Key provider.</param>
        public EasyCachingResponseCachingMiddleware(
            RequestDelegate next,
            IOptions <ResponseCachingOptions> options,
            IResponseCache cache,
            ILoggerFactory loggerFactory,
            IResponseCachingPolicyProvider policyProvider,
            IResponseCachingKeyProvider keyProvider)
            : base(next, options, loggerFactory, policyProvider, keyProvider)
        {
            FieldInfo cacheFieldInfo = typeof(ResponseCachingMiddleware).GetField("_cache", BindingFlags.NonPublic | BindingFlags.Instance);

            cacheFieldInfo.SetValue(this, cache);
        }
Пример #9
0
        internal Resolver(ResolverContext context)
        {
            Retries       = context.Retries;
            TimeOut       = context.Timeout;
            TransportType = context.TransportType;
            Recursion     = context.UseRecursion;
            DnsServers    = context.DnsServers.Count == 0 ? GetDnsServers() : context.DnsServers;
            UseCache      = context.UseCache;

            if (context.UseCache)
            {
                _cache = new ResponseCache(context.CacheSize);
            }
        }
        public NullCacheEntryTests()
        {
            // Setup Distributed Cache
            _fakeDistributedCache = A.Fake <IDistributedCache>();

            A.CallTo(() => _fakeDistributedCache.Get(Key)).Returns(null);
            A.CallTo(() => _fakeDistributedCache.GetAsync(Key, default(CancellationToken))).Returns(Task.FromResult <byte[]>(null));

            // Setup Serializer
            _fakeCacheSerializer = A.Fake <IDistributedCacheSerializer>();

            // Setup DistributedResponseCache
            _distributedResponseCache = new DistributedResponseCache(_fakeDistributedCache, _fakeCacheSerializer);
        }
        public IsolatedAccountEnvironment(IMessageSink messageSink)
        {
            authTestData = AuthTestData.LoadFromJsonFile();
            IResponseCache responseCache = authTestData.TestDataGenerateLevel switch
            {
                TestDataGenerationLevel.TestRun => new EmptyCache(),
                TestDataGenerationLevel.TempFolder => JsonFileResponseCache.InTempFolder(),
                TestDataGenerationLevel.CurrentDirectory => JsonFileResponseCache.InCurrentFolder(),
                _ => throw new ArgumentOutOfRangeException(nameof(authTestData.TestDataGenerateLevel), authTestData.TestDataGenerateLevel, null)
            };
            var log = new TestLog(messageSink);

            lifetime       = new Lifetime(log);
            externTestTool = new ExternTestTool(authTestData.ApiKey, responseCache, lifetime, log);
        }
Пример #12
0
        public OrchestrationTests()
        {
            // Setup Distributed Cache
            _fakeDistributedCache = A.Fake <IDistributedCache>();

            A.CallTo(() => _fakeDistributedCache.Get(Key)).Returns(_serializedValue);
            A.CallTo(() => _fakeDistributedCache.GetAsync(Key, default(CancellationToken))).Returns(_serializedValue);

            // Setup Serializer
            _fakeCacheSerializer = A.Fake <IDistributedCacheSerializer>();
            A.CallTo(() => _fakeCacheSerializer.Serialize(_deserializedValue)).Returns(_serializedValue);
            A.CallTo(() => _fakeCacheSerializer.Deserialize(_serializedValue)).Returns(_deserializedValue);

            // Setup DistributedResponseCache
            _distributedResponseCache = new DistributedResponseCache(_fakeDistributedCache, _fakeCacheSerializer);
        }
Пример #13
0
        public async Task <GeneratedAccount> ExecuteAsync(IHttpClient httpClient, IResponseCache cache)
        {
            var responseBody = await cache.TryGetAsync(organizationName) ?? await GenerateNewAccount();

            var response = DeserializeAccount(responseBody);

            var publicPartOfCertificate = await driveCertificatesReader.GetPublicPartOfCertificate(response.CertificateInfo.CertificateDrivePath);

            if (publicPartOfCertificate == null)
            {
                responseBody = await GenerateNewAccount();

                response = DeserializeAccount(responseBody);
                publicPartOfCertificate = await driveCertificatesReader.GetPublicPartOfCertificate(response.CertificateInfo.CertificateDrivePath) ??
                                          throw new InvalidOperationException("The content of newly generated account was not found");
            }

            return(ToGeneratedAccount(response, publicPartOfCertificate));
        public DistributedResponseCachingMiddleware(
            RequestDelegate next,
            IOptions <ResponseCachingOptions> options,
            ILoggerFactory loggerFactory,
            IResponseCachingPolicyProvider policyProvider,
            IResponseCache cache,
            IResponseCachingKeyProvider keyProvider)
            : base(next, options, loggerFactory, policyProvider, keyProvider)
        {
            var cacheFieldInfo = typeof(ResponseCachingMiddleware)
                                 .GetField(InternalCacheFieldName, BindingFlags.NonPublic | BindingFlags.Instance);

            if (cacheFieldInfo == null)
            {
                throw new Exception($"Failed to internal cache field named '{InternalCacheFieldName}'.");
            }

            cacheFieldInfo.SetValue(this, cache);
        }
        private async Task <Sender> ObtainCertificate(IHttpClient httpClient, IResponseCache cache)
        {
            if (sender.Certificate != null)
            {
                return(sender);
            }

            var certificateGenerationData = new CertificateGenerationData(
                sender.Inn,
                sender.Kpp,
                sender.OrgName,
                Surname: payer?.ChiefFullName?.Surname,
                FirstName: payer?.ChiefFullName?.Name,
                Patronymic: payer?.ChiefFullName?.Patronymic
                );
            var generatedCertificate = await new GenerateCertificateCommand(certificateGenerationData).ExecuteAsync(httpClient, cache);

            return(sender with
            {
                Certificate = Base64String.Encode(generatedCertificate.PublicKeyCertificate)
            });
        }
Пример #16
0
        public EasyCachingResponseCachingMiddleware(
            RequestDelegate next,
            IOptions <ResponseCachingOptions> options,
            ILoggerFactory loggerFactory,
            IResponseCache cache,
            IResponseCachingPolicyProvider policyProvider,
            IResponseCachingKeyProvider keyProvider)
        {
            ArgumentCheck.NotNull(next, nameof(next));
            ArgumentCheck.NotNull(options, nameof(options));
            ArgumentCheck.NotNull(loggerFactory, nameof(loggerFactory));
            ArgumentCheck.NotNull(policyProvider, nameof(policyProvider));
            ArgumentCheck.NotNull(cache, nameof(cache));
            ArgumentCheck.NotNull(keyProvider, nameof(keyProvider));

            _next           = next;
            _options        = options.Value;
            _logger         = loggerFactory.CreateLogger <ResponseCachingMiddleware>();
            _policyProvider = policyProvider;
            _cache          = cache;
            _keyProvider    = keyProvider;
        }
        /// <summary>
        /// <inheritdoc cref="ResponseCachingContext"/>
        /// </summary>
        /// <param name="metadatas">Action端点的 <see cref="EndpointMetadataCollection"/></param>
        /// <param name="cacheKeyGenerator"></param>
        /// <param name="responseCache"></param>
        /// <param name="cacheDeterminer"></param>
        /// <param name="options"></param>
        /// <param name="interceptorAggregator"></param>
        /// <param name="dumpStreamCapacity"></param>
        public ResponseCachingContext(EndpointMetadataCollection metadatas,
                                      ICacheKeyGenerator cacheKeyGenerator,
                                      IResponseCache responseCache,
                                      IResponseCacheDeterminer cacheDeterminer,
                                      ResponseCachingOptions options,
                                      InterceptorAggregator interceptorAggregator,
                                      int dumpStreamCapacity)
        {
            if (metadatas is null)
            {
                throw new ArgumentNullException(nameof(metadatas));
            }

            MaxCacheableResponseLength = Checks.ThrowIfMaxCacheableResponseLengthTooSmall(Metadata <IMaxCacheableResponseLengthMetadata>()?.MaxCacheableResponseLength ?? options.MaxCacheableResponseLength);

            MaxCacheKeyLength = options.MaxCacheKeyLength;

            KeyGenerator         = cacheKeyGenerator ?? throw new ArgumentNullException(nameof(cacheKeyGenerator));
            ResponseCache        = responseCache ?? throw new ArgumentNullException(nameof(responseCache));
            CacheDeterminer      = cacheDeterminer ?? throw new ArgumentNullException(nameof(cacheDeterminer));
            Duration             = Checks.ThrowIfDurationTooSmall(RequiredMetadata <IResponseDurationMetadata>().Duration);
            DurationMilliseconds = Duration * 1000;

            var executingLockMetadata = Metadata <IExecutingLockMetadata>();

            LockMillisecondsTimeout = Checks.ThrowIfLockMillisecondsTimeoutInvalid(executingLockMetadata?.LockMillisecondsTimeout ?? options.DefaultLockMillisecondsTimeout).Value;

            Interceptors       = interceptorAggregator;
            DumpStreamCapacity = Checks.ThrowIfDumpStreamInitialCapacityTooSmall(dumpStreamCapacity, nameof(dumpStreamCapacity));

            OnCannotExecutionThroughLock = options.OnCannotExecutionThroughLock ?? DefaultExecutionLockTimeoutFallback.SetStatus429;
            OnExecutionLockTimeout       = executingLockMetadata?.OnExecutionLockTimeout
                                           ?? options.OnExecutionLockTimeoutFallback
                                           ?? DefaultExecutionLockTimeoutFallback.SetStatus429;

            TMetadata?Metadata <TMetadata>() where TMetadata : class => metadatas.GetMetadata <TMetadata>();
Пример #18
0
 public PeopleEndpoint(IResponseCache responseCache)
     : base(responseCache)
 {
 }
Пример #19
0
 public EventsEndpoint(IResponseCache responseCache)
     : base(responseCache)
 {
 }
		public CachingActionProxy(IAction proxiedAction, IResponseCache cache)
		{
			this.proxiedAction = proxiedAction;
			this.cache = cache;
		}
Пример #21
0
 public BasecampApi(string accountId, string username, string password, IResponseCache responseCache)
     : base(accountId, username, password, responseCache)
 {
 }
Пример #22
0
 public TodosEndpoint(IResponseCache responseCache)
     : base(responseCache)
 {
 }
Пример #23
0
 public EndpointBase(IResponseCache responseCache)
 {
     ResponseCache = responseCache;
 }