private void SendHttpFailed <T>(IAppEvent <T> appEvent, Dictionary <string, object> values) where T : Event
{
var requestStatus =
RequestStatus.CreateFromCommandContext(appEvent.CommandBase.CommandContext, Status.FAILED, values);
_httpQueuedCommandStatusStorage.UpdateCommandStatus(requestStatus, appEvent.CommandBase);
}
public override void Consume(IAppEvent <AuctionRaised> message)
{
AuctionRaised ev = message.Event;
using (var session = _dbContext.Client.StartSession())
{
var opt = new TransactionOptions(
writeConcern: new WriteConcern(mode: "majority", journal: true)
);
try
{
_ = session.WithTransaction((handle, token) =>
{
UpdateAuction(ev, handle);
UpdateUser(ev, handle);
return(0);
}, transactionOptions: opt);
}
catch (Exception e)
{
_logger.LogError(e, "Cannot update read collections, appEvent: {@appEvent}", message);
_requestStatusService.TrySendRequestFailureToUser(message, ev.Bid.UserIdentity);
throw;
}
_requestStatusService.TrySendReqestCompletionToUser(message, ev.Bid.UserIdentity);
}
}
public override void Consume(IAppEvent <AuctionImageAdded> appEvent)
{
AddImg(appEvent.Event);
_requestStatusService.TrySendReqestCompletionToUser(appEvent, appEvent.Event.AuctionOwner);
}
public override void Consume(IAppEvent <TestEvent> appEvent)
{
OnConsume?.Invoke(appEvent);
if (Throws)
{
throw new Exception();
}
}
public virtual void Rollback(IAppEvent <Event> commandEvent)
{
OnRollback?.Invoke(commandEvent);
if (Throws)
{
throw new Exception();
}
}
public void SendRequestCompletionToAll <T>(IAppEvent <T> appEvent, Dictionary <string, object> values = null) where T : Event
{
if (appEvent.CommandBase.HttpQueued)
{
throw new QueryException("Cannot send request status to all of http queued command");
}
_wsRequestStatusService.SendRequestCompletionToAll(appEvent, values);
}
void IEventConsumer.Dispatch(object message)
{
IAppEvent <Event> appEventBase = (IAppEvent <Event>)message;
this.Consume(_appEventBuilder
.WithCorrelationId(appEventBase.CorrelationId)
.WithEvent(appEventBase.Event)
.WithCommand(appEventBase.CommandBase)
.Build <T>());
}
public void TrySendRequestFailureToUser <T>(IAppEvent <T> appEvent, UserIdentity user, Dictionary <string, object> values = null) where T : Event
{
try
{
SendRequestFailureToUser(appEvent, user, values);
}
catch (Exception)
{
_logger.LogDebug($"Cannot send event completion to user {user.UserName}");
}
}
private void _TimerEvnetHandler(IAppEvent e)
{
if (e.type == TimerEvent.TIMER_COMPLETE && this._isRequesting && this._www != null && this._request != null)
{
this._timeOutTimer.Reset();
this._behaviour.StopAllCoroutines();
this._www.Dispose();
ResultVO requestVO = this._request.data as ResultVO;
this.Result(new ResultVO(requestVO.id, requestVO.service, ErrorCode.TIME_OUT, null, requestVO.uniqueID));
}
}
public void Rollback(IAppEvent <Event> commandEvent)
{
var ev = (CreditsAdded)commandEvent.Event;
_logger.LogWarning("Canceling buyCredits command for user {@user}", ev.UserIdentity);
var user = _userRepository.FindUser(ev.UserIdentity);
user.CancelCredits(ev.CreditsCount);
_userRepository.UpdateUser(user);
}
public void SendRequestFailureToUser <T>(IAppEvent <T> appEvent, UserIdentity user, Dictionary <string, object> values = null) where T : Event
{
if (appEvent.CommandBase.HttpQueued)
{
SendHttpFailed(appEvent, values);
}
else
{
_wsRequestStatusService.SendRequestFailureToUser(appEvent, user, values);
}
}
private void TrySendHttpFailed <T>(IAppEvent <T> appEvent, Dictionary <string, object> values)
where T : Event
{
try
{
SendHttpFailed(appEvent, values);
}
catch (Exception)
{
}
}
private void TryExecuteCommandRollback(ICommandRollbackHandler handler, IAppEvent <Event> commandEvent)
{
//TODO Command rollback request status msg
try
{
handler.Rollback(commandEvent);
}
catch (Exception e)
{
_logger.LogError(e, "Catched exception in command rollback handler. Command: {@command}", commandEvent);
}
}
public virtual void Rollback(IAppEvent <Event> commandEvent)
{
try
{
var cmd = (CreateAuctionCommand)commandEvent.CommandBase;
var ev = (AuctionCreated)commandEvent.Event;
_auctionRepository.RemoveAuction(ev.AuctionId);
}
catch (Exception)
{
throw;
}
}
private static IEnumerable <IAppEvent> GetHandler(AppEventType eventType)
{
Type interfaceType = typeof(IAppEvent);
List <IAppEvent> result = new List <IAppEvent>();
foreach (var item in Assembly.GetExecutingAssembly().GetTypes().Where(t => interfaceType.IsAssignableFrom(t) && !t.IsInterface))
{
IAppEvent handler = (IAppEvent)Activator.CreateInstance(item);
result.Add(handler);
}
return(result.Where(i => i.EvenType == eventType));
}
public void Rollback(IAppEvent <Event> commandEvent)
{
var ev = (AuctionRaised)commandEvent.Event;
var auction = _auctionRepository.FindAuction(ev.Bid.AuctionId);
if (auction != null)
{
auction.RemoveBid(ev.Bid);
}
else
{
_logger.LogDebug("Bid rollback handler error, commandEvent: {@commandEvent}", commandEvent);
throw new CommandException($"Cannot find auction with id: {ev.Bid.AuctionId}");
}
_auctionRepository.UpdateAuction(auction);
}
public override void Consume(IAppEvent <BidCanceled> appEvent)
{
var session = _dbContext.Client.StartSession();
session.StartTransaction();
try
{
UpdateAuction(session, appEvent.Event);
UpdateUser(session, appEvent.Event);
session.CommitTransaction();
}
catch (Exception e)
{
_logger.LogError(e, "Cannot cancel bid, appEvent: {@appEvent}", appEvent);
throw;
}
}
public override void Consume(IAppEvent <UserRegistered> message)
{
UserRegistered ev = message.Event;
var userReadModel = new UserRead();
userReadModel.UserIdentity = new UserIdentityRead(ev.UserIdentity);
try
{
_dbContext.UsersReadModel.InsertOne(userReadModel);
}
catch (Exception)
{
throw;
}
}
public override void Consume(IAppEvent <AuctionCompleted> message)
{
AuctionCompleted ev = message.Event;
using (var session = _dbContext.Client.StartSession())
{
var opt = new TransactionOptions(
writeConcern: new WriteConcern(mode: "majority", journal: true)
);
_ = session.WithTransaction((handle, token) =>
{
UpdateAuction(handle, ev);
UserBidsUpdate(handle, ev);
return(0);
}, opt);
}
}
private void HandleErrorMessage(IMessage <Error> message, MessageReceivedInfo info)
{
try
{
_logger.LogWarning("Handling error message: {@message} with routingKey: {routingKey}", message, info.RoutingKey);
IAppEvent <Event> commandEvent = ParseEventFromMessage(message);
if (commandEvent != null)
{
var commandName = commandEvent.CommandBase?.GetType()
.Name;
var handler = RollbackHandlerRegistry.GetCommandRollbackHandler(commandName);
TryExecuteCommandRollback(handler, commandEvent);
}
else
{
_logger.LogError("Parsed command event is null! RoutingKey: {routingKey}", info.RoutingKey);
}
}
catch (Exception)
{
_logger.LogError("Cannot handle error message");
}
}
public override void Consume(IAppEvent <AuctionUpdateEventGroup> appEvent)
{
var filter = Builders <AuctionRead> .Filter.Eq(f => f.AuctionId, appEvent.Event.AggregateId.ToString());
var updates = new List <UpdateDefinition <AuctionRead> >();
appEvent.Event.UpdateEvents.ForEach(ev =>
updates.Add((UpdateDefinition <AuctionRead>) this.AsDynamic().UpdateAuction(appEvent.Event, ev)));
var update = Builders <AuctionRead> .Update.Combine(updates);
try
{
_dbContext.AuctionsReadModel.UpdateMany(filter, update);
_requestStatusService.TrySendReqestCompletionToUser(appEvent, appEvent.Event.AuctionOwner);
}
catch (Exception)
{
_logger.LogError("Cannot add image to read model");
_requestStatusService.TrySendRequestFailureToUser(appEvent, appEvent.Event.AuctionOwner);
throw;
}
}
public override void Consume(IAppEvent <AuctionBought> appEvent)
{
var ev = appEvent.Event;
using (var session = _readModelDbContext.Client.StartSession())
{
try
{
_ = session.WithTransaction((handle, token) =>
{
UpdateAuction(handle, ev);
UpdateBids(handle, ev);
return(0);
});
}
catch (Exception e)
{
_logger.LogError(e, "Cannot update read collections, appEvent: {@appEvent}", appEvent);
_requestStatusService.TrySendRequestFailureToUser(appEvent, ev.UserIdentity);
throw;
}
_requestStatusService.TrySendReqestCompletionToUser(appEvent, ev.UserIdentity);
}
}
public static UserRead AddCredits <T>(ReadModelDbContext dbContext, IAppEvent <T> appEvent,
decimal creditsCount, UserIdentity user,
IRequestStatusService requestStatusService) where T : Event
{
var filter = Builders <UserRead> .Filter.Eq(read => read.UserIdentity.UserId,
user.UserId.ToString());
var update = Builders <UserRead> .Update.Inc(read => read.Credits, creditsCount);
var userRead = dbContext.UsersReadModel.FindOneAndUpdate(filter, update);
if (userRead == null)
{
requestStatusService.TrySendRequestFailureToUser(appEvent, user);
throw new QueryException("Null userReadModel");
}
requestStatusService.TrySendReqestCompletionToUser(appEvent, user,
new Dictionary <string, object>()
{
{ "ammount", creditsCount }
});
return(userRead);
}
public override void Consume(IAppEvent <AuctionCreated> message)
{
var ev = message.Event;
var mapper = MapperConfigHolder.Configuration.CreateMapper();
var auction = mapper.Map <AuctionCreated, AuctionRead>(ev,
opt => opt.AfterMap((created, read) => mapper.Map(created.AuctionArgs, read)));
auction.DateCreated = DateTime.UtcNow;
try
{
_dbContext.AuctionsReadModel.WithWriteConcern(new WriteConcern(mode: "majority", journal: true))
.InsertOne(auction);
}
catch (Exception e)
{
_logger.LogWarning(e, "Cannot create an auction");
_requestStatusService.TrySendRequestFailureToUser(message, ev.AuctionArgs.Creator);
throw;
}
_requestStatusService.TrySendReqestCompletionToUser(message, ev.AuctionArgs.Creator);
}
public void METHOD()
{
var services = TestDepedencies.Instance.Value;
var user = new User();
user.Register("testUserName");
user.MarkPendingEventsAsHandled();
var product = new Product("test product name", "example description", Condition.New);
var sem = new SemaphoreSlim(0, 1);
var sem2 = new SemaphoreSlim(0, 1);
var correlationId = new CorrelationId("test_correlationId");
var categories = new List <string>()
{
"Fake category", "Fake subcategory", "Fake subsubcategory 0"
};
var userRepository = new Mock <IUserRepository>();
userRepository.Setup(f => f.FindUser(It.IsAny <UserIdentity>()))
.Returns(user);
var command = new CreateAuctionCommand(20.0m, product, DateTime.UtcNow.AddMinutes(10),
DateTime.UtcNow.AddDays(12),
categories, Tag.From(new[] { "tag1" }), "test auction name", false);
command.SignedInUser = user.UserIdentity;
IAppEvent <AuctionCreated> publishedEvent = null;
var eventHandler = new Mock <TestAuctionCreatedHandler>(
services.AppEventBuilder,
services.DbContext,
Mock.Of <IRequestStatusService>()
);
eventHandler.CallBase = true;
eventHandler
.Setup(f => f.Consume(It.IsAny <IAppEvent <AuctionCreated> >())
)
.Callback((IAppEvent <AuctionCreated> ev) =>
{
publishedEvent = ev;
sem.Release();
})
.CallBase();
services.SetupEventBus(eventHandler.Object);
var implProv = new Mock <IImplProvider>();
implProv
.Setup(f => f.Get <IAuctionRepository>())
.Returns(services.AuctionRepository);
RollbackHandlerRegistry.ImplProvider = implProv.Object;
var testRollbackHandler = new Mock <TestCreateAuctionRollbackHandler>(implProv.Object);
testRollbackHandler.CallBase = true;
testRollbackHandler
.Setup(f => f.Rollback(It.IsAny <IAppEvent <Event> >()))
.CallBase();
testRollbackHandler.Object.AfterAction = () => { sem2.Release(); };
var session = user.UserIdentity.GetAuctionCreateSession();
command.AuctionCreateSession = session;
var handlerDepedencies = new CreateAuctionCommandHandlerDepedencies()
{
auctionRepository = services.AuctionRepository,
auctionSchedulerService = services.SchedulerService,
eventBusService = services.EventBus,
logger = Mock.Of <ILogger <CreateAuctionCommandHandler> >(),
auctionCreateSessionService = services.GetAuctionCreateSessionService(session),
auctionImageRepository = services.AuctionImageRepository,
categoryBuilder = new CategoryBuilder(services.CategoryTreeService),
userRepository = userRepository.Object
};
var commandHandler = new TestCreateAuctionCommandHandler(handlerDepedencies, testRollbackHandler.Object);
commandHandler.Handle(command, CancellationToken.None);
if (!sem.Wait(TimeSpan.FromSeconds(60)))
{
Assert.Fail();
}
;
var createdAuciton = services.AuctionRepository.FindAuction(publishedEvent.Event.AuctionId);
if (!sem2.Wait(TimeSpan.FromSeconds(60)))
{
Assert.Fail();
}
;
var auctionAfterRollback = services.AuctionRepository.FindAuction(publishedEvent.Event.AuctionId);
testRollbackHandler.Verify(f => f.Rollback(It.IsAny <IAppEvent <Event> >()), Times.Once());
createdAuciton.Should()
.NotBe(null);
auctionAfterRollback.Should()
.Be(null);
}
public override void Consume(IAppEvent <AuctionCreated> message)
{
throw new Exception();
}
public override void Rollback(IAppEvent <Event> commandEvent)
{
base.Rollback(commandEvent);
AfterAction?.Invoke();
}
private bool CheckRollbackAppEvent(IAppEvent <Event> ev)
{
return(ev.CommandBase.GetType()
.Equals(typeof(TestCommandBase)) && ev.CorrelationId.Value.Equals("123") && ev.Event.GetType()
.Equals(typeof(TestEvent)));
}
public void AddListener(IAppEvent listener)
{
listeners.Add(listener);
}
public void Rollback(IAppEvent <Event> commandEvent)
{
_logger.LogDebug("Default command rollback handler for commandEvent: {commandEvent}", commandEvent);
}
