public RemoteServiceInvoker(IRpcClientFactory factory, IAddressResolver addressResolver, IHealthCheckService healthCheckService, ILogger <RemoteServiceInvoker> logger) { this._logger = logger; this._clientFactory = factory; this._healthCheckService = healthCheckService; this._addressResolver = addressResolver; }
public RedisProvider(string appName) { _context = new Lazy <RedisContext>(() => { if (CacheContainer.IsRegistered <RedisContext>(appName)) { return(CacheContainer.GetService <RedisContext>(appName)); } else { return(CacheContainer.GetInstances <RedisContext>(appName)); } }); _keySuffix = appName; _defaultExpireTime = new Lazy <long>(() => long.Parse(_context.Value._defaultExpireTime)); _connectTimeout = new Lazy <int>(() => int.Parse(_context.Value._connectTimeout)); if (CacheContainer.IsRegistered <ICacheClient <IDatabase> >(CacheTargetType.Redis.ToString())) { addressResolver = CacheContainer.GetService <IAddressResolver>(); _cacheClient = new Lazy <ICacheClient <IDatabase> >(() => CacheContainer.GetService <ICacheClient <IDatabase> >(CacheTargetType.Redis.ToString())); } else { _cacheClient = new Lazy <ICacheClient <IDatabase> >(() => CacheContainer.GetInstances <ICacheClient <IDatabase> >(CacheTargetType.Redis.ToString())); } }
public async Task <bool> SignAsync( IInOutTransaction tx, IEnumerable <ITxOutput> spentOutputs, IAddressResolver addressResolver, CancellationToken cancellationToken = default(CancellationToken)) { if (tx == null) { throw new ArgumentNullException(nameof(tx)); } Log.Verbose("Sign request for transaction {@id}", tx.Id); if (IsLocked) { Log.Warning("Wallet locked"); return(false); } await tx .SignAsync( addressResolver : addressResolver, keyStorage : KeyStorage, spentOutputs : spentOutputs, cancellationToken : cancellationToken) .ConfigureAwait(false); Log.Verbose("Transaction {@id} successfully signed", tx.Id); return(true); }
public async Task <bool> SignAsync( IAddressResolver addressResolver, IKeyStorage keyStorage, IEnumerable <ITxOutput> spentOutputs, CancellationToken cancellationToken = default(CancellationToken)) { if (spentOutputs == null) { throw new ArgumentNullException(nameof(spentOutputs)); } foreach (var spentOutput in spentOutputs) { var address = spentOutput.DestinationAddress(Currency); var walletAddress = await addressResolver .ResolveAddressAsync( currency : Currency, address : address, cancellationToken : cancellationToken) .ConfigureAwait(false); if (walletAddress?.KeyIndex == null) { Log.Error($"Can't find private key for address {address}"); return(false); } Sign(keyStorage.GetPrivateKey(Currency, walletAddress.KeyIndex), spentOutput); } return(true); }
public RemoteInvokeService(IAddressResolver addressResolver, ITransportClientFactory transportClientFactory, ILogger<RemoteInvokeService> logger, IHealthCheckService healthCheckService) { _addressResolver = addressResolver; _transportClientFactory = transportClientFactory; _logger = logger; _healthCheckService = healthCheckService; }
public RemoteInvokeService(IHashAlgorithm hashAlgorithm, IAddressResolver addressResolver, ITransportClientFactory transportClientFactory, ILogger <RemoteInvokeService> logger, IHealthCheckService healthCheckService) { _addressResolver = addressResolver; _transportClientFactory = transportClientFactory; _logger = logger; _healthCheckService = healthCheckService; }
public Task<PartitionAddressInformation> ResolveAsync( DocumentServiceRequest request, bool forceRefresh, CancellationToken cancellationToken) { IAddressResolver resolver = this.GetAddressResolver(request); return resolver.ResolveAsync(request, forceRefresh, cancellationToken); }
/// <summary> /// Initializes a new instance of the <see cref="InsolvencyOrderAddressCollectionResponse" /> class. /// </summary> /// <param name="addressResolver">The <see cref="IAddressResolver" /> used for resolving address routes.</param> /// <param name="pagingLinks">The <see cref="IPagingLinks" /> used to generate a paged resource.</param> /// <param name="requestReader">The <see cref="IRequestReader" /> used to read the request.</param> public InsolvencyOrderAddressCollectionResponse(IAddressResolver addressResolver, IPagingLinks pagingLinks, IRequestReader requestReader) { Requires.NotNull(addressResolver, nameof(addressResolver)); Requires.NotNull(pagingLinks, nameof(pagingLinks)); Requires.NotNull(requestReader, nameof(requestReader)); this.addressResolver = addressResolver; this.pagingLinks = pagingLinks; this.requestReader = requestReader; }
public void ConstructingADisputeResponse_WithNullAddressResolver_ThrowsArgumentNullException() { // Arrange IAddressResolver addressResolver = null; // Act void ResponseObject() => new DisputeResponse(addressResolver); // Assert Assert.ThrowsException <ArgumentNullException>((Action)ResponseObject); }
public void ConstructingAInsolvencyResponse_WithNullAddressResolver_ThrowsArgumentNullException() { // Arrange IAddressResolver addressResolver = null; var includeReader = new Mock <IIncludeReader>(); // Act void ConstructResponseObject() => new InsolvencyOrderResponse(addressResolver, includeReader.Object); // Assert Assert.ThrowsException <ArgumentNullException>((Action)ConstructResponseObject); }
public ClientInitializer( IAddressResolver addressResolver, ApplicationDbContext context, OpenIddictApplicationManager <OpenIddictApplication> manager, IScopeCollection scopes, IConfiguration configuration) { this.addressResolver = addressResolver; this.context = context; this.manager = manager; this.scopes = scopes; this.configuration = configuration; }
public void ConstructingADisputeResponse_WithNullAddressResolver_HasCorrectParameterNameInException() { // Arrange const string expectedParameterName = "addressResolver"; IAddressResolver addressResolver = null; // Act void ResponseObject() => new DisputeResponse(addressResolver); // Assert ExceptionAssert.HasCorrectParameterNameForArgumentException(ResponseObject, expectedParameterName); }
public void Setup() { var result = new AddressResolvedResult( StatusCode.Success, true, IPAddress.Loopback, RegionInfo.CurrentRegion); var moq = new Mock <MockAddressResolver>(); moq.Setup(x => x.ResolveAddressAsync(result.Address)).ReturnsAsync(() => result); this._addressResolver = moq.Object; }
public void ConstructingAInsolvencyOrderCollectionResponse_WithNullAddressResolver_ThrowsArgumentNullException() { // Arrange const IAddressResolver addressResolver = null; var pagingLinksMock = new Mock <IPagingLinks>(); var requestReaderMock = new Mock <IRequestReader>(); var includeReader = new Mock <IIncludeReader>(); // Act void ConstructResponseObject() => new InsolvencyOrderCollectionResponse(addressResolver, pagingLinksMock.Object, requestReaderMock.Object, includeReader.Object); // Assert Assert.ThrowsException <ArgumentNullException>((Action)ConstructResponseObject); }
public void ConstructingAInsolvencyResponse_WithNullAddressResolver_HasCorrectParameterNameInException() { // Arrange IAddressResolver addressResolver = null; var includeReader = new Mock <IIncludeReader>(); const string expectedParameterName = "addressResolver"; // Act void ConstructResponseObject() => new InsolvencyOrderResponse(addressResolver, includeReader.Object); // Assert ExceptionAssert.HasCorrectParameterNameForArgumentException( ConstructResponseObject, expectedParameterName); }
public async Task <PartitionAddressInformation> ResolveAsync( DocumentServiceRequest request, bool forceRefresh, CancellationToken cancellationToken) { IAddressResolver resolver = this.GetAddressResolver(request); PartitionAddressInformation partitionAddressInformation = await resolver.ResolveAsync(request, forceRefresh, cancellationToken); if (!this.partitionKeyRangeLocationCache.TryAddPartitionLevelLocationOverride(request)) { return(partitionAddressInformation); } resolver = this.GetAddressResolver(request); return(await resolver.ResolveAsync(request, forceRefresh, cancellationToken)); }
public void ConstructingADisputeCollectionResponse_WithNullAddressResolver_ThrowsArgumentNullException() { // Arrange IAddressResolver addressResolver = null; var mockedPagingLinks = new Mock <IPagingLinks>(); var mockedRequestReader = new Mock <IRequestReader>(); // Act void ResponseObject() => new DisputeCollectionResponse( addressResolver, mockedPagingLinks.Object, mockedRequestReader.Object); // Assert Assert.ThrowsException <ArgumentNullException>((Action)ResponseObject); }
public void ConstructingADisputeCollectionResponse_WithNullAddressResolver_HasCorrectParameterNameInException() { // Arrange const string expectedParameterName = "addressResolver"; IAddressResolver addressResolver = null; var mockedPagingLinks = new Mock <IPagingLinks>(); var mockedRequestReader = new Mock <IRequestReader>(); // Act void ResponseObject() => new DisputeCollectionResponse( addressResolver, mockedPagingLinks.Object, mockedRequestReader.Object); // Assert ExceptionAssert.HasCorrectParameterNameForArgumentException(ResponseObject, expectedParameterName); }
public void ConstructingAInsolvencyOrderCollectionResponse_WithNullAddressResolver_HasCorrectParameterNameInException() { // Arrange const string expectedParameterName = "addressResolver"; const IAddressResolver addressResolver = null; var includeReader = new Mock <IIncludeReader>(); var pagingLinksMock = new Mock <IPagingLinks>(); var requestReaderMock = new Mock <IRequestReader>(); // Act void ConstructResponseObject() => new InsolvencyOrderCollectionResponse(addressResolver, pagingLinksMock.Object, requestReaderMock.Object, includeReader.Object); // Assert ExceptionAssert.HasCorrectParameterNameForArgumentException( ConstructResponseObject, expectedParameterName); }
public async Task <bool> SignAsync( IAddressResolver addressResolver, IKeyStorage keyStorage, IEnumerable <ITxOutput> spentOutputs, CurrencyConfig currencyConfig, CancellationToken cancellationToken = default) { if (spentOutputs == null) { throw new ArgumentNullException(nameof(spentOutputs)); } var btcBasedConfig = currencyConfig as BitcoinBasedConfig; foreach (var spentOutput in spentOutputs) { var address = spentOutput.DestinationAddress(btcBasedConfig.Network); var walletAddress = await addressResolver .GetAddressAsync( currency : Currency, address : address, cancellationToken : cancellationToken) .ConfigureAwait(false); if (walletAddress?.KeyIndex == null) { Log.Error($"Can't find private key for address {address}"); return(false); } using var securePrivateKey = keyStorage.GetPrivateKey( currency: btcBasedConfig, keyIndex: walletAddress.KeyIndex, keyType: walletAddress.KeyType); Sign(securePrivateKey, spentOutput, btcBasedConfig); } return(true); }
public StoreClient CreateStoreClient( IAddressResolver addressResolver, ISessionContainer sessionContainer, IServiceConfigurationReader serviceConfigurationReader, IAuthorizationTokenProvider authorizationTokenProvider, bool enableRequestDiagnostics = false, bool enableReadRequestsFallback = false, bool useFallbackClient = true, bool useMultipleWriteLocations = false) { this.ThrowIfDisposed(); if (useFallbackClient && this.fallbackClient != null) { return(new StoreClient( addressResolver, sessionContainer, serviceConfigurationReader, authorizationTokenProvider, this.protocol, // Use the fallback client instead of the default one. this.fallbackClient, enableRequestDiagnostics, enableReadRequestsFallback, useMultipleWriteLocations)); } return(new StoreClient( addressResolver, sessionContainer, serviceConfigurationReader, authorizationTokenProvider, this.protocol, this.transportClient, enableRequestDiagnostics, enableReadRequestsFallback, useMultipleWriteLocations)); }
public UserAddressResolver(IAddressResolver addressResolver) { _addressResolver = addressResolver; }
public RemoteInvokeService(IAddressResolver addressResolver, ITransportClientFactory transportClientFactory, ILogger<RemoteInvokeService> logger) { _addressResolver = addressResolver; _transportClientFactory = transportClientFactory; _logger = logger; }
public CarWorkshopAddressResolver(IAddressResolver addressResolver) { _addressResolver = addressResolver; }
public ClientSocketFactory(IAddressResolver addressResolver) { _addressResolver = addressResolver; }
public RemoteInvokeService(IAddressResolver addressResolver, ITransportClientFactory transportClientFactory, ILogger <RemoteInvokeService> logger) { _addressResolver = addressResolver; _transportClientFactory = transportClientFactory; _logger = logger; }
/// <summary> /// Initializes a new instance of the <see cref="InsolvencyOrderAddressResponse" /> class. /// </summary> /// <param name="addressResolver">The <see cref="IAddressResolver" /> used for resolving address routes.</param> public InsolvencyOrderAddressResponse(IAddressResolver addressResolver) { Requires.NotNull(addressResolver, nameof(addressResolver)); this.addressResolver = addressResolver; }
private async Task <RemoteInvokeResultMessage> RetryExectueAsync(Context ctx, IAddressResolver resolver, string serviceId, TransportMessage transportMessage) { var address = await resolver.ResolverAsync(serviceId); ctx["address"] = address; var client = _clientFactory.CreateClientAsync(address.CreateEndPoint()); return(await client.SendAsync(transportMessage)); }