public void CanLoadStateFromSnapshotStore()
{
const string ACTOR_NAME = "test-actorX";
const string EXPECTED_STATE = "Ken Hartley Reed";
var snapshots = InMemoryPersistence.Get(Sys).SnapshotSource;
snapshots.Add(new SnapshotEntry()
{
Id = ACTOR_NAME + "_0",
PersistenceId = ACTOR_NAME,
SequenceNr = 0,
Snapshot = new TestActorState()
{
State = EXPECTED_STATE
},
Timestamp = 1
});
// verify the SnapshotOffer was triggered when we create our actor
EventFilter.Info(message: "SnapshotOffer received.").ExpectOne(() =>
{
var snapshotActor = Sys.ActorOf(Props.Create(() => new PersistBySnapshotTestActor()), ACTOR_NAME);
snapshotActor.Tell(new GetStateCommand());
});
ExpectMsg <string>(msg => msg == EXPECTED_STATE);
}
protected override void PreStart()
{
base.PreStart();
_journalCollection = InMemoryPersistence.Get(Context.System).JournalSource;
_metadataCollection = InMemoryPersistence.Get(Context.System).MetadataSource;
}
protected BaseRepositoryTest()
{
Persistence = new InMemoryPersistence();
Streams = new StreamsFactory(Persistence);
AggregateFactory = new DefaultAggregateFactory();
}
public void CanStoreToJournal()
{
const string ACTOR_NAME = "test-actor";
const string EXPECTED_STATE01 = "Bob was here";
const string EXPECTED_STATE02 = "So was Red";
var actor = Sys.ActorOf(Props.Create(() => new PersistByJournalTestActor()), ACTOR_NAME);
actor.Tell(new SetStateCommand(EXPECTED_STATE01));
ExpectNoMsg();
actor.Tell(new SetStateCommand(EXPECTED_STATE02));
ExpectNoMsg();
var journal = InMemoryPersistence.Get(Sys).JournalSource;
Assert.Equal(2, journal.Count);
Assert.Equal(ACTOR_NAME, journal[0].PersistenceId);
Assert.Equal(EXPECTED_STATE01, (journal[0].Payload as SetStateCommand).NewState);
Assert.Equal(ACTOR_NAME, journal[1].PersistenceId);
Assert.Equal(EXPECTED_STATE02, (journal[1].Payload as SetStateCommand).NewState);
var metadata = InMemoryPersistence.Get(Sys).MetadataSource;
Assert.Equal(1, metadata.Count);
Assert.Equal(2, metadata[0].SequenceNr);
Assert.Equal(ACTOR_NAME, metadata[0].PersistenceId);
}
public static void Main(string[] args)
{
string qos = args[0];
string topic = args[1];
string client_id = args[2];
int publishCount = Int32.Parse(args[3]);
MqttQos Qos = ParseQos(qos);
using (var pers = new InMemoryPersistence())
{
var client = new MqttClient(topic, client_id, Qos, publishCount, pers);
while (!client.Finished)
{
try
{
client.Run();
}
catch (Exception ex)
{
Console.WriteLine("{0} : {1}", client_id, ex.ToString());
}
Thread.Sleep(TimeSpan.FromSeconds(1));
}
}
Console.WriteLine("{0} done", client_id);
}
public void Cleanup()
{
_inmemoryStore = null;
Task.WaitAll(
_mongoPersistence.Select(x => x.Drop(CancellationToken.None)).ToArray()
);
}
public override void SetData()
{
advertisementService = ServiceProvider.GetService <IAdvertisementService>();
Assert.NotNull(advertisementService);
data = ServiceProvider.GetService <InMemoryPersistence>();
Assert.NotNull(data);
}
private PersistedQueue <T> CreatePersistedQueue <T>(int inMemoryCapacity = 1024)
{
IPersistence <T> persistence = new InMemoryPersistence <T>();
PersistedQueueConfiguration config = new PersistedQueueConfiguration {
MaxItemsInMemory = inMemoryCapacity
};
return(new PersistedQueue <T>(persistence, config));
}
public void SetUp()
{
container = new WindsorContainer();
memoryPersistence = new InMemoryPersistence();
sut = new Repository(new AggregateFactoryEx(container.Kernel), new StreamsFactory(memoryPersistence));
var snapshotMemoryPersistence = new InMemoryPersistence();
snapshotStore = new DefaultSnapshotStore(snapshotMemoryPersistence);
}
protected IPersistence CreatePersistence()
{
networkSimulator = new AlwaysThrowsNetworkSimulator();
var options = new InMemoryPersistenceOptions
{
NetworkSimulator = networkSimulator
};
var persistence = new InMemoryPersistence(options);
return(persistence);
}
void IHandleProfile.ProfileActivated()
{
InMemoryPersistence.UseAsDefault();
if (!Configure.Instance.Configurer.HasComponent <IManageMessageFailures>())
{
Configure.Instance.InMemoryFaultManagement();
}
WindowsInstallerRunner.RunInstallers = true;
}
/// <summary>
/// Tells the endpoint to not enforce durability (using InMemory storages, non durable messages, ...).
/// </summary>
public Endpoint AsVolatile()
{
InMemoryPersistence.UseAsDefault();
Configure.Transactions.Disable();
Configure.Transactions.Advanced(s => s.DoNotWrapHandlersExecutionInATransactionScope()
.DisableDistributedTransactions());
Advanced(settings => settings.DisableDurableMessages());
return(this);
}
public SampleApp(IPersistence store, string name, bool useSnapshots, bool quiet, bool fast)
{
_quiet = quiet;
_name = name;
_rooms = 32;
_storeProfile = new ProfileDecorator(store);
_streams = new StreamsFactory(_storeProfile);
_aggregateFactory = new DefaultAggregateFactory();
var network = fast
? (INetworkSimulator) new NoNetworkLatencySimulator()
: (INetworkSimulator) new ReliableNetworkSimulator(10, 50);
_appProjections = new AppProjections(network, quiet);
_poller = new PollingClient(_storeProfile, 0, _appProjections, this._loggerFactory);
if (useSnapshots)
{
_cloneProfiler = new TaskProfilingInfo("Cloning state");
var inMemoryPersistence = new InMemoryPersistence(new InMemoryPersistenceOptions
{
CloneFunc = CloneSnapshot
});
_snapshotProfile = new ProfileDecorator(inMemoryPersistence);
_snapshots = new DefaultSnapshotStore(_snapshotProfile);
}
_unboundedOptions = new ExecutionDataflowBlockOptions()
{
MaxDegreeOfParallelism = DataflowBlockOptions.Unbounded,
BoundedCapacity = DataflowBlockOptions.Unbounded,
EnsureOrdered = false,
MaxMessagesPerTask = DataflowBlockOptions.Unbounded
};
_boundedOptions = new ExecutionDataflowBlockOptions()
{
MaxDegreeOfParallelism = Environment.ProcessorCount * 8,
BoundedCapacity = 500,
EnsureOrdered = true
};
if (store is MongoPersistence)
{
_unboundedOptions.MaxDegreeOfParallelism = Environment.ProcessorCount * 4;
_unboundedOptions.BoundedCapacity = 2000;
}
}
static IMapPersistence OnMapPersistence(IServiceContainer container, Type type)
{
var messageSender = (IMessageSender)container.GetService(typeof(IMessageSender));
var sagaStorage = (IStoreSagaData)container.GetService(typeof(IStoreSagaData));
var persistenceMapper = new PersistenceMapper();
var persistence = new InMemoryPersistence(messageSender, sagaStorage);
persistenceMapper.Add(nameof(MintRequest), persistence);
persistenceMapper.Add(nameof(Order), persistence);
persistenceMapper.Add(nameof(Token), persistence);
return(persistenceMapper);
}
public override void SetData()
{
advertisementQuery = ServiceProvider.GetService <IAdvertisementsQuery>();
Assert.NotNull(advertisementQuery);
mediatR = ServiceProvider.GetService <IMediator>();
Assert.NotNull(mediatR);
controller = new AdvertisementsController(mediatR, advertisementQuery);
Assert.NotNull(controller);
data = ServiceProvider.GetService <InMemoryPersistence>();
Assert.NotNull(data);
}
protected void Init()
{
var url = new MongoUrl(ConfigurationManager.ConnectionStrings["readmodel"].ConnectionString);
var client = new MongoClient(url);
_db = client.GetDatabase(url.DatabaseName);
_collection = _db.GetCollection <SimpleTestAtomicReadModel>(
CollectionNames.GetCollectionName <SimpleTestAtomicReadModel>());
_persistence = new InMemoryPersistence();
_db.Drop();
_identityManager = new IdentityManager(new CounterService(_db));
_mongoBsonCollection = _db.GetCollection <BsonDocument>(CollectionNames.GetCollectionName <SimpleTestAtomicReadModel>());
}
public void CanSaveStateToSnapshotStore()
{
const string EXPECTED_STATE = "Bob was here";
var snapshotActor = Sys.ActorOf(Props.Create(() => new PersistBySnapshotTestActor()), "test-actor");
snapshotActor.Tell(new SetStateCommand(EXPECTED_STATE));
ExpectNoMsg();
var snapshots = InMemoryPersistence.Get(Sys).SnapshotSource;
Assert.Equal(1, snapshots.Count);
Assert.IsType(typeof(TestActorState), snapshots[0].Snapshot);
Assert.Equal(EXPECTED_STATE, (snapshots[0].Snapshot as TestActorState).State);
}
private async Task InMemoryInt()
{
IPersistence <int> persistence = new InMemoryPersistence <int>();
PersistedQueueConfiguration config = new PersistedQueueConfiguration {
MaxItemsInMemory = itemsToKeepInMemory
};
PersistedQueue <int> queue = new PersistedQueue <int>(persistence, config);
for (int i = 0; i < totalItems; i++)
{
queue.Enqueue(i);
}
for (int i = 0; i < totalItems; i++)
{
await queue.DequeueAsync();
}
}
public void OneTimeSetup()
{
var url = new MongoUrl(ConfigurationManager.ConnectionStrings["readmodel"].ConnectionString);
var client = new MongoClient(url);
_db = client.GetDatabase(url.DatabaseName);
_db.Drop();
_collection = _db.GetCollection <SimpleTestAtomicReadModel>(
CollectionNames.GetCollectionName <SimpleTestAtomicReadModel>());
_persistence = new InMemoryPersistence();
_collectionWrapper = new AtomicMongoCollectionWrapper <SimpleTestAtomicReadModel>(
_db,
new AtomicReadModelFactory(),
new LiveAtomicReadModelProcessor(new AtomicReadModelFactory(), new CommitEnhancer(), _persistence));
}
public when_an_event_is_received()
{
Bus = new InMemoryMessageBus();
var config = Bus.Configuration;
var persistence = new InMemoryPersistence(config.MessageSender, config.Sagas.Storage);
var repository = new Repository <InventoryItem>(new InMemoryEventStore <Guid>(persistence));
var commandHandlers = new InventoryCommandHandlers(repository);
var projector = new Projector();
config.CommandHandlers.Register <CreateInventoryItem>(() => commandHandlers);
config.CommandHandlers.Register <RenameInventoryItem>(() => commandHandlers);
config.CommandHandlers.Register <DeactivateInventoryItem>(() => commandHandlers);
config.EventReceivers.Register <InventoryItemCreated>(() => projector);
config.EventReceivers.Register <InventoryItemRenamed>(() => projector);
config.EventReceivers.Register <InventoryItemDeactivated>(() => projector);
Products = projector.Products;
Bus.Start();
}
public void CanLoadFromJournal()
{
const string ACTOR_NAME = "test-actor";
const string EXPECTED_STATE01 = "State01";
const string EXPECTED_STATE02 = "State02";
var journal = InMemoryPersistence.Get(Sys).JournalSource;
var metadata = InMemoryPersistence.Get(Sys).MetadataSource;
journal.Add(new JournalEntry()
{
Id = ACTOR_NAME + "_2",
PersistenceId = ACTOR_NAME,
SequenceNr = 2,
Manifest = "",
Payload = new SetStateCommand(EXPECTED_STATE02)
});
journal.Add(new JournalEntry()
{
Id = ACTOR_NAME + "_1",
PersistenceId = ACTOR_NAME,
SequenceNr = 1,
Manifest = "",
Payload = new SetStateCommand(EXPECTED_STATE01)
});
metadata.Add(new MetadataEntry()
{
Id = ACTOR_NAME,
PersistenceId = ACTOR_NAME,
SequenceNr = 2
});
EventFilter.Info(message: "Recovering SetStateCommand.").Expect(2, () =>
{
var actor = Sys.ActorOf(Props.Create(() => new PersistByJournalTestActor()), ACTOR_NAME);
actor.Tell(new GetStateCommand());
ExpectMsg <string>(msg => msg == EXPECTED_STATE02);
});
}
public InMemoryJournal()
{
_settings = InMemoryPersistence.Get(Context.System).JournalSettings;
}
private IPersistence Create()
{
var store = new InMemoryPersistence(cloneFunc: Clone);
return(store);
}
public InMemoryPersistenceSpecFixture()
{
persistence = new InMemoryPersistence();
}
public AdvertisementsQuery(InMemoryPersistence database, IMapper mapper)
{
this.database = database;
this.mapper = mapper;
}
public void SetUp()
{
persistence = new InMemoryPersistence();
streamfactory = new StreamsFactory(persistence);
sut = new StreamProcessorManager(persistence);
}
public void load_memory_parallel()
{
_inmemoryStore = new InMemoryPersistence();
paralell_worker(_inmemoryStore);
}
public void load_memory_async()
{
_inmemoryStore = new InMemoryPersistence();
async_worker(_inmemoryStore);
}
public void load_memory_task()
{
_inmemoryStore = new InMemoryPersistence();
task_worker(_inmemoryStore);
}
public AdvertisementService(InMemoryPersistence database)
{
this.database = database;
}
