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