public void Configure()
{
_actorSystem = ActorSystem.Create("test");
_transport = new LocalAkkaEventBusTransport(_actorSystem);
Waiter = new AkkaMessageLocalWaiter(_actorSystem, _transport, TimeSpan.FromSeconds(1));
_results = ConfigureWaiter(Waiter);
}
public LocalTransportProxyActor()
{
var localTransport = new LocalAkkaEventBusTransport(Context.System);
Receive <Publish>(p =>
{
localTransport.Publish(p.Msg);
Sender.Tell(PublishAck.Instance);
});
Receive <PublishMany>(p =>
{
var messages = p.Messages.Select(m => m.Msg).ToArray();
localTransport.Publish(messages);
Sender.Tell(PublishManyAck.Instance);
});
Receive <Subscribe>(s =>
{
localTransport.Subscribe(s.Topic, s.Actor, s.Notificator);
Sender.Tell(SubscribeAck.Instance);
});
Receive <Unsubscribe>(us =>
{
localTransport.Unsubscribe(us.Actor, us.Topic);
Sender.Tell(UnsubscribeAck.Instance);
});
}
public AkkaWaiter_message_test_filtered_message()
{
_transport = new LocalAkkaEventBusTransport(Sys);
var waiter = new LocalMessagesWaiter(Sys, _transport, TimeSpan.FromSeconds(2));
waiter.Expect <string>(m => m.Like("Msg"));
_results = waiter.Start(TimeSpan.FromSeconds(10));
}
//Given_waiter_subscribed_for_message_When_publishing_message()
public AkkaWaiter_One_Message_Test()
{
var actorSystem = TestActorSystem.Create();
var transport = new LocalAkkaEventBusTransport(actorSystem);
var waiter = new LocalMessagesWaiter(actorSystem, transport, TimeSpan.FromSeconds(10));
waiter.Expect <string>();
_results = waiter.Start(TimeSpan.FromSeconds(10));
_testmsg = "TestMsg";
transport.Publish(_testmsg, MessageMetadata.Empty);
}
public void Given_waiter_subscribed_for_message_When_publishing_message()
{
var actorSystem = ActorSystem.Create("test");
var transport = new LocalAkkaEventBusTransport(actorSystem);
_waiter = new AkkaMessageLocalWaiter(actorSystem, transport, TimeSpan.FromSeconds(10));
_waiter.Expect <string>();
_results = _waiter.Start(TimeSpan.FromSeconds(1));
_testmsg = "TestMsg";
transport.Publish(_testmsg);
}
//TODO: refactor to good config via IContainerConfiguration
public static void Init(IUnityContainer container,
ActorSystem actorSystem,
TransportMode transportMode,
IQuartzConfig config = null)
{
container.Register(new QuartzSchedulerConfiguration(config ?? new PersistedQuartzConfig()));
container.RegisterInstance <IRetrySettings>(new InMemoryRetrySettings(5,
TimeSpan.FromMinutes(10),
new DefaultExceptionPolicy()));
//TODO: replace with config
IActorTransport transport;
switch (transportMode)
{
case TransportMode.Standalone:
transport = new LocalAkkaEventBusTransport(actorSystem);
break;
case TransportMode.Cluster:
transport = new DistributedPubSubTransport(actorSystem);
break;
default:
throw new ArgumentException(nameof(transportMode));
}
container.RegisterInstance <IPublisher>(transport);
container.RegisterInstance <IActorSubscriber>(transport);
container.RegisterInstance <IActorTransport>(transport);
container.RegisterType <IHandlerActorTypeFactory, DefaultHandlerActorTypeFactory>();
container.RegisterType <IAggregateActorLocator, DefaultAggregateActorLocator>();
container.RegisterType <IPersistentChildsRecycleConfiguration, DefaultPersistentChildsRecycleConfiguration>();
container.RegisterInstance <IAppInsightsConfiguration>(AppInsightsConfigSection.Default ??
new DefaultAppInsightsConfiguration());
container.RegisterInstance <IPerformanceCountersConfiguration>(PerformanceCountersConfigSection.Default ??
new DefaultPerfCountersConfiguration());
container.RegisterInstance(actorSystem);
var executor = new AkkaCommandExecutor(actorSystem, transport);
container.RegisterType <ICommandExecutor, AkkaCommandExecutor>();
var messageWaiterFactory = new MessageWaiterFactory(executor, actorSystem, TimeSpan.FromSeconds(15), transport);
container.RegisterInstance <IMessageWaiterFactory>(messageWaiterFactory);
container.RegisterInstance <ICommandWaiterFactory>(messageWaiterFactory);
}
public AkkaEventsChronicle(AkkaConfiguration akkaConf)
{
_system = akkaConf.CreateSystem();
_system.AddDependencyResolver(new UnityDependencyResolver(new UnityContainer(), _system));
_transport = new LocalAkkaEventBusTransport(_system);
var routingActor =
_system.ActorOf(Props.Create(() => new LocalSystemRoutingActor(new DefaultHandlerActorTypeFactory(),
new LocalAkkaEventBusTransport(_system))));
var actorLocator = new DefaultAggregateActorLocator();
Router = new ActorMessagesRouter(routingActor);
}
public void Message_process_actor_produce_fault_with_sagaId_from_incoming_message(string payload)
{
var message = new SampleAggregateChangedEvent(payload, Guid.NewGuid(), DateTime.Now, Guid.NewGuid());
var transport = new LocalAkkaEventBusTransport(Sys);
transport.Subscribe <IMessageMetadataEnvelop <Fault <SampleAggregateChangedEvent> > >(TestActor);
var actor = Sys.ActorOf(Props.Create(() =>
new MessageHandlingActor <SampleAggregateChangedEvent, OddFaultyMessageHandler>(
new OddFaultyMessageHandler(transport),
transport)));
actor.Tell(message);
var fault = ExpectMsg <IMessageMetadataEnvelop <Fault <SampleAggregateChangedEvent> > >();
Assert.AreEqual(message.SagaId, fault.Message.SagaId);
}
[InlineData("10")] //, Description = "planned exception from message processor")]
public void Message_process_actor_produce_fault_with_processId_from_incoming_message(string payload)
{
var message = new BalloonTitleChanged(payload, Guid.NewGuid().ToString(), DateTime.Now, Guid.NewGuid().ToString());
var transport = new LocalAkkaEventBusTransport(Sys);
transport.Subscribe <IMessageMetadataEnvelop>(TestActor);
var actor =
Sys.ActorOf(Props.Create(
() =>
new MessageHandleActor <BalloonTitleChanged, BalloonTitleChangedOddFaultyMessageHandler>(
new BalloonTitleChangedOddFaultyMessageHandler(transport),
transport)));
actor.Tell(new MessageMetadataEnvelop <DomainEvent>(message, MessageMetadata.Empty));
var fault = FishForMessage <IMessageMetadataEnvelop>(m => m.Message is IFault).Message as IFault;
Assert.Equal(message.ProcessId, fault.ProcessId);
Assert.IsAssignableFrom <Fault <BalloonTitleChanged> >(fault);
}
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);
}
