public TSagaState LoadSagaState <TSaga, TSagaState>(Guid id) where TSagaState : AggregateBase where TSaga : class, ISagaInstance
{
var name = AggregateActorName.New <TSagaState>(id).ToString();
var actor = LoadActorByDI <SagaActor <TSaga, TSagaState> >(name).Result;
return((TSagaState)actor.Saga.Data);
}
public void AggregateActor_can_be_created_with_iServiceLocator_injected()
{
var actorRef = GridNode.System.ActorOf(GridNode.System.DI().Props <AggregateActor <TestAggregate> >(),
AggregateActorName.New <TestAggregate>(Guid.NewGuid()).Name);
Assert.NotNull(actorRef);
}
public void Save <T>(T aggr) where T : IAggregate
{
var persistId = AggregateActorName.New <T>(aggr.Id).ToString();
_eventRepository.Save(persistId, aggr.GetUncommittedEvents().Cast <DomainEvent>().ToArray());
aggr.ClearUncommittedEvents();
}
protected IActorRef LookupInstanceSagaActor <TSaga, TData>(Guid id) where TData : ISagaState
{
var sagaName = AggregateActorName.New <SagaDataAggregate <TData> >(id).Name;
var sagaType = typeof(ISagaInstance <TSaga, TData>).BeautyName();
return(GetSagaActor(sagaType, sagaName));
}
public void Result_metadata_has_processed_correct_filled_history_step()
{
var step = _answer.Metadata.History.Steps.First();
Assert.AreEqual(AggregateActorName.New <SampleAggregate>(_command.AggregateId).Name, step.Who);
Assert.AreEqual(AggregateActor <SampleAggregate> .CommandExecutionCreatedAnEvent, step.Why);
Assert.AreEqual(AggregateActor <SampleAggregate> .PublishingEvent, step.What);
}
public void Result_metadata_has_processed_correct_filled_history_step()
{
var step = _schedulingCommandFault.Metadata.History.Steps.First();
Assert.AreEqual(AggregateActorName.New <TestAggregate>(_command.AggregateId).Name, step.Who);
Assert.AreEqual(AggregateActor <TestAggregate> .CommandRaisedAnError, step.Why);
Assert.AreEqual(AggregateActor <TestAggregate> .CreatedFault, step.What);
}
protected override void SaveInJournal <TAggregate>(Guid id, params DomainEvent[] messages)
{
using (var eventsRepo = ActorSystemEventRepository.New(new AutoTestAkkaConfiguration(), new EventsAdaptersCatalog()))
{
var persistId = AggregateActorName.New <BalanceAggregate>(id).Name;
eventsRepo.Save(persistId, messages);
}
}
protected override string GetChildActorName(object message)
{
if (message is ICommand)
{
return(AggregateActorName.New <TAggregate>(_locator.GetAggregateId(message as ICommand))
.ToString());
}
return(null);
}
public void Result_metadata_has_processed_correct_filled_history_step()
{
var step = _answer.Metadata.History.Steps.First();
var name = AggregateActorName.New <SagaDataAggregate <SoftwareProgrammingSagaData> >(SagaId);
Assert.AreEqual(name.Name, step.Who);
Assert.AreEqual(SagaActorLiterals.SagaProducedACommand, step.Why);
Assert.AreEqual(SagaActorLiterals.PublishingCommand, step.What);
}
public void Replay <TAggregate>(Guid aggregateId, Predicate <object> eventFilter = null) where TAggregate : AggregateBase
{
eventFilter = eventFilter ?? (o => true);
var replayActor =
_system.ActorOf(Props.Create(() => new EventsReplayActor <TAggregate>(_transport, eventFilter)),
AggregateActorName.New <TAggregate>(aggregateId).Name);
replayActor.Ask <PlayFinished>(new Play());
}
public EventSourcedActor(IConstructAggregates aggregateConstructor,
ISnapshotsPersistencePolicy policy,
IPublisher publisher)
{
PersistenceId = Self.Path.Name;
SnapshotsPolicy = policy;
_aggregateConstructor = aggregateConstructor;
Publisher = publisher;
Id = AggregateActorName.Parse <T>(Self.Path.Name).Id;
State = (AggregateBase)aggregateConstructor.Build(typeof(T), Id, null);
Monitor = new ActorMonitor(Context, typeof(T).Name);
Command <GracefullShutdownRequest>(req =>
{
Monitor.IncrementMessagesReceived();
DeleteSnapshots(SnapshotsPolicy.GetSnapshotsToDelete());
Become(Terminating);
});
Command <CheckHealth>(s => Sender.Tell(new HealthStatus(s.Payload)));
Command <SaveSnapshotSuccess>(s =>
{
NotifyWatchers(s);
SnapshotsPolicy.MarkSnapshotSaved(s.Metadata);
});
Command <NotifyOnPersistenceEvents>(c =>
{
var waiter = c.Waiter ?? Sender;
if (IsRecoveryFinished)
{
waiter.Tell(RecoveryCompleted.Instance);
}
_persistenceWaiters.Add(waiter);
});
Recover <DomainEvent>(e =>
{
State.ApplyEvent(e);
SnapshotsPolicy.MarkActivity(e.CreatedTime);
});
Recover <SnapshotOffer>(offer =>
{
SnapshotsPolicy.MarkSnapshotApplied(offer.Metadata);
State = _aggregateConstructor.Build(typeof(T), Id, (IMemento)offer.Snapshot);
});
Recover <RecoveryCompleted>(message =>
{
_log.Debug("Recovery for actor {Id} is completed", PersistenceId);
NotifyWatchers(message);
});
}
protected virtual void SaveInJournal <TAggregate>(Guid id, params DomainEvent[] messages) where TAggregate : AggregateBase
{
string persistId = AggregateActorName.New <TAggregate>(id).ToString();
var persistActor = GridNode.System.ActorOf(
Props.Create(() => new EventsRepositoryActor(persistId)), Guid.NewGuid().ToString());
foreach (var o in messages)
{
persistActor.Ask <EventsRepositoryActor.Persisted>(new EventsRepositoryActor.Persist(o)).Wait(Timeout);
}
}
public void State_saga_actor_can_be_created()
{
var actorType = typeof(SagaActor <StateSagas.SampleSaga.SoftwareProgrammingSaga, SoftwareProgrammingSagaState>);
var props = GridNode.System.DI().Props(actorType);
var name = new AggregateActorName(typeof(SoftwareProgrammingSagaState), Guid.NewGuid()).ToString();
var actor = GridNode.System.ActorOf(props, name);
actor.Tell(new CheckHealth());
ExpectMsg <HealthStatus>();
}
public T LoadAggregate <T>(Guid id) where T : AggregateBase
{
var agr = Aggregate.Empty <T>(id);
var persistId = AggregateActorName.New <T>(id).ToString();
var events = _eventRepository.Load(persistId);
foreach (var e in events.SelectMany(e => _eventsAdaptersCatalog.Update(e)))
{
((IAggregate)agr).ApplyEvent(e);
}
return(agr);
}
public void Instance_saga_actor_can_be_created()
{
var actorType = typeof(SagaActor <ISagaInstance <SoftwareProgrammingSaga, SoftwareProgrammingSagaData>,
SagaDataAggregate <SoftwareProgrammingSagaData> >);
var props = GridNode.System.DI().Props(actorType);
var name =
new AggregateActorName(typeof(SagaDataAggregate <SoftwareProgrammingSagaData>), Guid.NewGuid()).ToString();
var actor = GridNode.System.ActorOf(props, name);
actor.Tell(new CheckHealth());
ExpectMsg <HealthStatus>();
}
public AggregateVersion <T>[] Load <T>(Guid id) where T : IAggregate
{
var serializer = new WireJsonSerializer();
using (var repo = new RawSnapshotsRepository(_writeString))
return(repo.Load(AggregateActorName.New <T>(id).Name)
.Select(s =>
{
var memento = (IMemento)serializer.FromBinary(s.Snapshot, typeof(IMemento));
var aggregate = (T)_aggregatesConstructor.Build(typeof(T), id, memento);
aggregate.ClearUncommittedEvents(); //in case json will call public constructor
return new AggregateVersion <T>(aggregate, s.Timestamp);
}).ToArray());
}
public async Task Instance_saga_actor_has_correct_path_when_saga_is_raised_by_domain_message()
{
var msg = new GotTiredEvent(Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid(), Guid.NewGuid());
await GridNode.NewDebugWaiter()
.Expect <MakeCoffeCommand>()
.Create()
.Publish(msg);
var sagaActorName = AggregateActorName.New <SagaDataAggregate <SoftwareProgrammingSagaData> >(msg.SagaId).ToString();
var sagaActor = LookupInstanceSagaActor <SoftwareProgrammingSaga, SoftwareProgrammingSagaData>(msg.SagaId);
Assert.NotNull(sagaActor);
}
public void Add <T>(T aggregate) where T : IAggregate
{
var serializer = new WireJsonSerializer();
using (var repo = new RawSnapshotsRepository(_writeString))
{
var snapshot = aggregate.GetSnapshot();
var item = new SnapshotItem()
{
Manifest = snapshot.GetType().AssemblyQualifiedShortName(),
PersistenceId = AggregateActorName.New <T>(aggregate.Id).Name,
Snapshot = serializer.ToBinary(snapshot),
Timestamp = BusinessDateTime.UtcNow
};
repo.Save(item.PersistenceId, item);
}
}
public EventsReplayActor(IPublisher publisher, Predicate <object> eventFilter)
{
_publisher = publisher;
_eventFilter = eventFilter;
PersistenceId = AggregateActorName.Parse <TAggregate>(Self.Path.Name).ToString();
Command <Play>(c =>
{
_waiter = Sender;
if (!IsRecoveryFinished)
{
return;
}
ReplayEvents();
});
Recover <DomainEvent>(e => _eventsStream.Add(e));
}
public void Given_only_aggregate_events_persisted_it_can_be_loaded(IRepository <DomainEvent> eventRepo, AggregateRepository aggrRepo)
{
try
{
_sourceId = Guid.NewGuid();
_createdEvent = new SampleAggregateCreatedEvent("initial value", _sourceId);
_changedEvent = new SampleAggregateChangedEvent("changed value", _sourceId);
string persistenceId = AggregateActorName.New <SampleAggregate>(_sourceId).ToString();
eventRepo.Save(persistenceId, _createdEvent, _changedEvent);
_aggregate = aggrRepo.LoadAggregate <SampleAggregate>(_sourceId);
Assert.AreEqual(_sourceId, _aggregate.Id);
Assert.AreEqual(_changedEvent.Value, _aggregate.Value);
}
finally
{
eventRepo.Dispose();
aggrRepo.Dispose();
}
}
public void Aggregate_actor_produce_fault_with_sagaId_from_command()
{
var command = new GoSleepCommand(Guid.Empty, Guid.Empty).CloneWithSaga(Guid.NewGuid());
var transport = new LocalAkkaEventBusTransport(Sys);
transport.Subscribe <MessageMetadataEnvelop <Fault <GoSleepCommand> > >(TestActor);
var actor = Sys.ActorOf(Props.Create(() =>
new AggregateActor <HomeAggregate>(new HomeAggregateHandler(),
new TypedMessageActor <ScheduleCommand>(TestActor),
new TypedMessageActor <Unschedule>(TestActor),
transport,
new SnapshotsPersistencePolicy(TimeSpan.FromSeconds(1), 1, 5),
new AggregateFactory()
)),
AggregateActorName.New <HomeAggregate>(command.Id).Name);
actor.Tell(new MessageMetadataEnvelop <ICommand>(command, new MessageMetadata(command.Id)));
var fault = ExpectMsg <MessageMetadataEnvelop <Fault <GoSleepCommand> > >(TimeSpan.FromDays(1));
Assert.AreEqual(command.SagaId, fault.Message.SagaId);
}
private void CheckWriteModel(IReadOnlyCollection <BalanceChangePlan> balanceManipulationPlans)
{
Sys.AddDependencyResolver(new UnityDependencyResolver(GridNode.Container, Sys));
var props = Sys.DI().Props <AggregateActor <Account> >();
Console.WriteLine();
var aggregateActors = new List <Tuple <BalanceChangePlan, AggregateActor <Account> > >();
foreach (var plan in balanceManipulationPlans)
{
Console.WriteLine($"Checking write model for account {plan.AccountId}");
var name = AggregateActorName.New <Account>(plan.AccountId).ToString();
var balanceActor = ActorOfAsTestActorRef <AggregateActor <Account> >(props, name);
aggregateActors.Add(Tuple.Create(plan, balanceActor.UnderlyingActor));
}
//TODO: remove this dirty hack for wait until actors recover
Thread.Sleep(2000);
//TODO: refactor this dirty hack to wait until actor recovers
foreach (var plan in aggregateActors)
{
CheckAmount(plan.Item2.Aggregate.Amount.Amount, plan.Item1, "write model");
}
}
/// <summary>
/// Loads aggregate using Sys actor system
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="id"></param>
/// <returns></returns>
public virtual T LoadAggregate <T>(Guid id) where T : AggregateBase
{
var name = AggregateActorName.New <T>(id).ToString();
return(LoadAggregate <T>(name).Result);
}
protected override string GetChildActorName(object message)
{
return(AggregateActorName.New <TSagaState>(GetChildActorId(message)).ToString());
}
protected IActorRef LookupAggregateActor <T>(Guid id) where T : IAggregate
{
var name = AggregateActorName.New <T>(id).Name;
return(ResolveActor($"akka://LocalSystem/user/Aggregate_{typeof(T).Name}/{name}"));
}
