IRequestClient <TRequest, TResponse> IRequestClientFactory <TRequest, TResponse> .CreateRequestClient(ConsumeContext consumeContext,
TimeSpan?timeout, TimeSpan?timeToLive, Action <SendContext <TRequest> > callback)
{
Action <SendContext <TRequest> > actualCallback = null;
if (_callback != null)
{
if (callback != null)
{
actualCallback = x =>
{
_callback(x);
callback(x);
}
}
;
else
{
actualCallback = _callback;
}
}
else if (callback != null)
{
actualCallback = callback;
}
RequestTimeout requestTimeout = timeout ?? RequestTimeout.None;
var client = _destinationAddress == null
? _clientFactory.CreateRequestClient <TRequest>(consumeContext, requestTimeout)
: _clientFactory.CreateRequestClient <TRequest>(consumeContext, _destinationAddress, requestTimeout);
return(new MessageRequestClient <TRequest, TResponse>(client, timeToLive ?? _timeToLive, actualCallback));
}
public async Task <Guid> DispatchAsync <TCommand>(TCommand command) where TCommand : class, ICommand
{
IValidator <TCommand> validator = _context.GetService <IValidator <TCommand> >();
if (validator.IsNotNull())
{
ValidationResult validationResult = await validator.ValidateAsync(command);
if (!validationResult.IsValid)
{
throw new ValidationException(validationResult.Errors);
}
}
command.CorrelationId = _guidService.New;
IRequestClient <TCommand> client = _clientFactory.CreateRequestClient <TCommand>(new Uri("queue:commands"), TimeSpan.FromMinutes(10));
MassTransit.Response <FWTL.Common.Cqrs.Responses.Response> response = await client.GetResponse <FWTL.Common.Cqrs.Responses.Response>(command);
if (response.Message.StatusCode == HttpStatusCode.BadRequest)
{
throw new AppValidationException(response.Message.Errors);
}
if (response.Message.StatusCode == HttpStatusCode.InternalServerError)
{
throw new InvalidOperationException(response.Message.Id.ToString());
}
return(response.Message.Id);
}
async Task <IMessageClient> CreateMessageClient <T>(Type messageType, CancellationToken cancellationToken)
where T : class
{
var messageClient = new MessageClient <T>(this);
var handle = _consumePipeConnector.ConnectInstance(messageClient);
try
{
if (_log.IsDebugEnabled)
{
_log.DebugFormat("Requesting Link to {0} (client-id: {1})", TypeMetadataCache <T> .ShortName, ClientId);
}
var request = _clientFactory.CreateRequestClient <Link <T> >().Create(new { ClientId }, cancellationToken);
var response = await request.GetResponse <Up <T> >().ConfigureAwait(false);
return(messageClient);
}
catch (Exception)
{
handle.Disconnect();
throw;
}
}
public async Task <TResult> DispatchAsync <TQuery, TResult>(TQuery query)
where TQuery : class, IQuery
{
//await TraitValidationAsync<TQuery, IPagingTrait>(query);
var validator = _context.GetService <IValidator <TQuery> >();
if (validator.IsNotNull())
{
var validationResult = await validator.ValidateAsync(query);
if (!validationResult.IsValid)
{
throw new ValidationException(validationResult.Errors);
}
}
var client = _clientFactory.CreateRequestClient <TQuery>(new Uri("queue:queries"), TimeSpan.FromMinutes(10));
var response = await client.GetResponse <Common.Cqrs.Responses.Response <TResult> >(query);
if (response.Message.StatusCode == HttpStatusCode.BadRequest)
{
throw new AppValidationException(response.Message.Errors);
}
if (response.Message.StatusCode == HttpStatusCode.InternalServerError)
{
throw new InvalidOperationException(response.Message.Id.ToString());
}
return(response.Message.Result);
}
public async Task Setup()
{
_clientFactory = await Bus.ConnectClientFactory(TestTimeout);
_requestClient = _clientFactory.CreateRequestClient <PingMessage>(InputQueueAddress, TestTimeout);
_response = _requestClient.GetResponse <PongMessage>(new PingMessage());
}
public MassTransitHubLifetimeManager(IPublishEndpoint publishEndpoint,
IClientFactory clientFactory,
IHubProtocolResolver hubProtocolResolver)
{
_publishEndpoint = publishEndpoint;
_groupManagementRequestClient = clientFactory.CreateRequestClient <GroupManagement <THub> >(TimeSpan.FromSeconds(20));
_protocols = hubProtocolResolver.AllProtocols;
}
public async Task Link(CancellationToken cancellationToken)
{
LogContext.Debug?.Log("Linking: {ClientId} {MessageType}", ClientId, TypeMetadataCache <TMessage> .ShortName);
var client = _clientFactory.CreateRequestClient <Link <TMessage> >();
var response = await client.GetResponse <Up <TMessage> >(new { ClientId }, cancellationToken).ConfigureAwait(false);
var serviceAddress = response.Message.Service.ServiceAddress;
var instance = response.Message.Instance;
var instanceContext = await _instanceCache.GetOrAdd(instance.InstanceId, instance).ConfigureAwait(false);
_distribution.Add(instanceContext);
LogContext.Debug?.Log("Linked: {ClientId} {MessageType} {ServiceAddress}", ClientId, TypeMetadataCache <TMessage> .ShortName, serviceAddress);
_serviceAddress.TrySetResult(serviceAddress);
}
public async Task <CommandResponse> SendAsync <TCommand>(object command, CancellationToken cancellationToken = default)
where TCommand : class, ICommand
{
try
{
var client = _clientFactory.CreateRequestClient <TCommand>(_timeOut);
var request = client.Create(command, cancellationToken);
var response = await request.GetResponse <CommandResponse>();
return(response.Message);
}
catch (RequestTimeoutException ex)
{
throw new TimeoutException(
string.Format(
"The request timed out after {0} seconds.", _timeOut.Seconds), ex);
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <TResult> DispatchAsync <TQuery, TResult>(TQuery command)
where TQuery : class, IQuery
{
var validator = _context.GetService <IValidator <TQuery> >();
if (validator.IsNotNull())
{
var validationResult = validator.Validate(command);
if (!validationResult.IsValid)
{
throw new ValidationException(validationResult.Errors);
}
}
var client = _clientFactory.CreateRequestClient <TQuery>(new Uri("queue:queries"), TimeSpan.FromMinutes(10));
var response = await client.GetResponse <Common.Commands.Response <TResult> >(command);
if (response.Message.Errors.Any())
{
throw new AppValidationException(response.Message.Errors);
}
return(response.Message.Result);
}
public async Task <Guid> DispatchAsync <TCommand>(TCommand command) where TCommand : class, ICommand
{
var validator = _context.GetService <IValidator <TCommand> >();
if (validator.IsNotNull())
{
var validationResult = validator.Validate(command);
if (!validationResult.IsValid)
{
throw new ValidationException(validationResult.Errors);
}
}
var client =
_clientFactory.CreateRequestClient <TCommand>(new Uri("queue:commands"), TimeSpan.FromMinutes(10));
var response = await client.GetResponse <Response>(command);
if (response.Message.Errors.Any())
{
throw new AppValidationException(response.Message.Errors);
}
return(response.Message.Id);
}
public void ConfigureServices(IServiceCollection services)
{
ILogger logger = InitLogger(services);
IMongoDatabase mongodb = InitMongoDb();
ConnectionMultiplexer redisMultiplexer = InitRedis();
IConnection rabbitMqConn = InitRabbitMqConn();
IBusControl massTransitBus = InitMassTransit();
IClientFactory massTransitClientFactory = massTransitBus.CreateClientFactory();
#region Various
//ITokenExtractor
services.AddTransient(typeof(ITokenExtractor), (serviceProvider) =>
{
return(new TokenExtractor(_rTokenConfig, new SymmetricKeyProvider(_rTokenKeyConfig)));
});
#endregion
#region Commands
//IGenerateRefreshTokenCommand
services.AddTransient(typeof(IGenerateRefreshTokenCommand), (serviceProvider) =>
{
IMongoCollection <AccountRTokenInfo> rtokensRepo = mongodb.GetCollection <AccountRTokenInfo>(_accountRTokensCollectionConfig.Name);
return(new GenerateRefreshTokenCommand(_rTokenConfig,
new SymmetricKeyProvider(_rTokenKeyConfig),
new GuidBasedSecretGenerator(),
rtokensRepo,
logger));
});
//IGenerateShortTokenCommand
services.AddTransient(typeof(IGenerateShortTokenCommand), (serviceProvider) =>
{
var revokedTokensRedisCollectionConfigs = new RedisCollectionConfig(_config.GetSection("redis").GetSection("revokedTokensCollection"));
RedisCachedRepo <string> revokedTokensRedisRepo = new RedisCachedRepo <string>(redisMultiplexer.GetDatabase(), revokedTokensRedisCollectionConfigs.CollectionName, new DefaultSerializer(), logger);
return(new GenerateShortTokenCommand(new TokenExtractor(_rTokenConfig, new SymmetricKeyProvider(_rTokenKeyConfig)),
revokedTokensRedisRepo,
new SymmetricKeyProvider(_sTokenKeyConfig),
new GuidBasedSecretGenerator(),
_sTokenConfig,
logger));
});
//IRevokeAllTokensForAccountCommand
services.AddTransient(typeof(IRevokeAllTokensForAccountCommand), (serviceProvider) =>
{
IMongoCollection <AccountRTokenInfo> rtokensRepo = mongodb.GetCollection <AccountRTokenInfo>(_accountRTokensCollectionConfig.Name);
var revokedTokensRedisCollectionConfigs = new RedisCollectionConfig(_config.GetSection("redis").GetSection("revokedTokensCollection"));
RedisCachedRepo <string> revokedTokensRedisRepo = new RedisCachedRepo <string>(redisMultiplexer.GetDatabase(), revokedTokensRedisCollectionConfigs.CollectionName, new DefaultSerializer(), logger);
var command = new RevokeAllTokensForAccountCommand(rtokensRepo, logger);
var exchangeConfigs = new RabbitMqExchangeConfigs(_config.GetSection("rabbitMq").GetSection("refreshTokenRevokedEventExchange"));
command.AddSubsciber(new RabbitMqEventPublisher <RefreshTokenRevokedEvent>(
new RabbitMqProducer <RefreshTokenRevokedEvent>(rabbitMqConn, exchangeConfigs, logger),
logger));
command.AddSubsciber(new RevokedTokenRedisCacher(revokedTokensRedisRepo, logger));
return(command);
});
//IRevokeTokenCommand
services.AddTransient(typeof(IRevokeTokenCommand), (serviceProvider) =>
{
IMongoCollection <AccountRTokenInfo> rtokensRepo = mongodb.GetCollection <AccountRTokenInfo>(_accountRTokensCollectionConfig.Name);
var revokedTokensRedisCollectionConfigs = new RedisCollectionConfig(_config.GetSection("redis").GetSection("revokedTokensCollection"));
RedisCachedRepo <string> revokedTokensRedisRepo = new RedisCachedRepo <string>(redisMultiplexer.GetDatabase(), revokedTokensRedisCollectionConfigs.CollectionName, new DefaultSerializer(), logger);
var command = new RevokeTokenCommand(rtokensRepo, logger);
var exchangeConfigs = new RabbitMqExchangeConfigs(_config.GetSection("rabbitMq").GetSection("refreshTokenRevokedEventExchange"));
command.AddSubsciber(new RabbitMqEventPublisher <RefreshTokenRevokedEvent>(
new RabbitMqProducer <RefreshTokenRevokedEvent>(rabbitMqConn, exchangeConfigs, logger),
logger));
command.AddSubsciber(new RevokedTokenRedisCacher(revokedTokensRedisRepo, logger));
return(command);
});
#endregion
#region Queries
//IGetAllTokensForAccountQuery
services.AddTransient(typeof(IGetAllTokensForAccountQuery), (serviceProvider) =>
{
IMongoCollection <AccountRTokenInfo> rtokensRepo = mongodb.GetCollection <AccountRTokenInfo>(_accountRTokensCollectionConfig.Name);
return(new GetAllTokensForAccountQuery(rtokensRepo, logger));
});
#endregion
#region MassTransit
services.AddTransient(typeof(IRequestClient <UserClaimsRequest>), (serviceProvider) =>
{
var massTransitChannelName = _config.GetSection("rabbitMq").GetSection("getUserClaimsMassTransitChannel")["Name"];
var requestClient = massTransitClientFactory.CreateRequestClient <UserClaimsMQRequest>(new Uri($"rabbitmq://{_rabbitmqConfigs.Host}/{massTransitChannelName}"));
return(requestClient);
});
services.AddTransient(typeof(IRequestClient <AuthValidationRequest>), (serviceProvider) =>
{
var massTransitChannelName = _config.GetSection("rabbitMq").GetSection("validateCredentialsMassTransitChannel")["Name"];
var requestClient = massTransitClientFactory.CreateRequestClient <AuthValidationMQRequest>(new Uri($"rabbitmq://{_rabbitmqConfigs.Host}/{massTransitChannelName}"));
return(requestClient);
});
#endregion
#region Mvc Framework
var mvcBuilder = services.AddMvc();
MvcConfigProvider mvcConfigProvider = new MvcConfigProvider();
mvcBuilder.AddMvcOptions(mvcConfigProvider.GetMvcOptionsConfigurer())
.AddJsonOptions(mvcConfigProvider.GetJsonOptionsConfigurer());
services.AddSession();
#endregion
}
public IRequestClient <T> CreateRequestClient <T>(Uri destinationAddress, RequestTimeout timeout)
where T : class
{
return(_clientFactory.CreateRequestClient <T>(destinationAddress, timeout));
}
public Task <IRequestClient <T> > GetRequestClient <T>(TimeSpan settingsRequestTimeout)
where T : class
{
return(Task.FromResult(_clientFactory.CreateRequestClient <T>(_targetEndpointAddress, settingsRequestTimeout)));
}
public HubLifetimeScope(IPublishEndpoint bus, IClientFactory clientFactory)
{
PublishEndpoint = bus;
RequestClient = clientFactory.CreateRequestClient <GroupManagement <THub> >();
}
public async Task Setup()
{
_clientFactory = await Bus.CreateReplyToClientFactory();
_requestClient = _clientFactory.CreateRequestClient <PingMessage>(InputQueueAddress, TestTimeout);
}
IRequestClient <T> IClientFactory.CreateRequestClient <T>(RequestTimeout timeout)
{
return(_clientFactory.CreateRequestClient <T>(timeout));
}
public async Task Setup()
{
_clientFactory = await Bus.CreateReplyToClientFactory();
_requestClient = _clientFactory.CreateRequestClient <PingMessage>(InputQueueAddress, TimeSpan.FromSeconds(8));
}