public PostgresqlJournalWriter(MemstateSettings settings)
: base(settings)
{
Ensure.NotNull(settings, nameof(settings));
_serializer = settings.CreateSerializer();
_settings = new PostgresqlSettings(settings);
}
public PostgresqlProvider(MemstateSettings settings)
{
_log = settings.CreateLogger <PostgresqlProvider>();
_settings = settings;
Settings = new PostgresqlSettings(settings);
}
public async Task FileJournalSmokeTest()
{
var settings = new MemstateSettings();
var fileName = Path.GetTempFileName();
var journalWriter = new FileJournalWriter(settings, fileName, 0, int.MaxValue);
var subSource = new FileJournalSubscriptionSource(journalWriter);
var records = new List <JournalRecord>();
var sub = subSource.Subscribe(0, records.Add);
for (int i = 0; i < 1000; i++)
{
var command = new AddStringCommand(i.ToString());
journalWriter.Send(command);
}
await journalWriter.DisposeAsync().ConfigureAwait(false);
sub.Dispose();
subSource.Dispose();
Assert.Equal(1000, records.Count);
var reader = new FileJournalReader(fileName, settings);
records.Clear();
foreach (var record in reader.GetRecords())
{
records.Add(record);
}
Assert.True(records.Select(r => (int)r.RecordNumber).SequenceEqual(Enumerable.Range(0, 1000)));
await reader.DisposeAsync().ConfigureAwait(false);
File.Delete(fileName);
}
public PostgresqlSettings(MemstateSettings settings)
: base(settings, ConfigurationKey)
{
Ensure.NotNull(settings, nameof(settings));
_memstateSettings = settings;
}
private static void RunClient()
{
MemstateSettings config = new MemstateSettings();
config.LoggerFactory.AddConsole((category, level) => true);
Console.Write("Connecting to localhost:3001 ... ");
var client = new MemstateClient <KeyValueStore <int> >(config);
client.ConnectAsync().Wait();
Console.WriteLine("connected!");
Console.WriteLine("Set 'KEY' = 42");
var cmd = new Set <int>("KEY", 42);
var version = client.ExecuteAsync(cmd).Result;
Console.WriteLine("Version returned: " + version);
Console.WriteLine("Get 'KEY'");
var query = new Get <int>("KEY");
var node = client.ExecuteAsync(query).Result;
Console.WriteLine($"Value: {node.Value}, version: {node.Version}");
Console.WriteLine("Hit enter to exit");
Console.ReadLine();
}
public KernelConcurrencyTests(ITestOutputHelper testOutputHelper)
{
var config = new MemstateSettings();
_bank = new AccountModel();
_kernel = new Kernel(config, _bank);
}
public void CanGetDefaultSerializer()
{
MemstateSettings config = new MemstateSettings();
var serializer = config.CreateSerializer();
Assert.NotNull(serializer);
}
public async Task SubscriptionDeliversPreExistingCommands(MemstateSettings settings)
{
settings.LoggerFactory.AddProvider(new TestOutputLoggingProvider(_log));
settings.StreamName = _randomStreamName;
var provider = settings.CreateStorageProvider();
const int NumRecords = 50;
var journalWriter = provider.CreateJournalWriter(0);
for (var i = 0; i < NumRecords; i++)
{
journalWriter.Send(new AddStringCommand(i.ToString()));
}
await journalWriter.DisposeAsync().ConfigureAwait(false);
var records = new List <JournalRecord>();
var subSource = provider.CreateJournalSubscriptionSource();
if (!provider.SupportsCatchupSubscriptions())
{
Assert.Throws <NotSupportedException>(() => subSource.Subscribe(0, records.Add));
}
else
{
subSource.Subscribe(0, records.Add);
await WaitForConditionOrThrow(() => records.Count == NumRecords).ConfigureAwait(false);
Assert.Equal(Enumerable.Range(0, NumRecords), records.Select(r => (int)r.RecordNumber));
}
}
public void Setup()
{
var config = new MemstateSettings();
_bank = new AccountModel();
_kernel = new Kernel(config, _bank);
}
public Session(MemstateSettings config, Engine <T> engine)
{
_engine = engine;
_logger = config.LoggerFactory.CreateLogger <Session <T> >();
_engine.CommandExecuted += SendMatchingEvents;
_subscriptions = new ConcurrentDictionary <Type, EventMatcher>();
}
public async Task Start(string[] arguments)
{
_running = true;
_settings = new MemstateSettings(arguments);
_settings.WithInmemoryStorage();
_settings.LoggerFactory.AddConsole((category, level) => true);
_engine = new EngineBuilder(_settings).Build <KeyValueStore <int> >();
_host = new WebHostBuilder()
.UseKestrel()
.UseContentRoot(Directory.GetCurrentDirectory())
.UseStartup <Web.Startup>()
.ConfigureServices(services => services.AddSingleton(_settings))
.Build();
_producerThread = new Thread(Producer);
_consumerThread = new Thread(Consumer);
_producerThread.Start();
_consumerThread.Start();
await _host.StartAsync();
}
public async Task SubscriptionDeliversFutureCommands(MemstateSettings settings)
{
const int NumRecords = 5;
settings.LoggerFactory.AddProvider(new TestOutputLoggingProvider(_log));
settings.StreamName = _randomStreamName;
var provider = settings.CreateStorageProvider();
var records = new List <JournalRecord>();
var subSource = provider.CreateJournalSubscriptionSource();
var sub = subSource.Subscribe(0, records.Add);
var writer = provider.CreateJournalWriter(0);
for (var i = 0; i < NumRecords; i++)
{
writer.Send(new AddStringCommand(i.ToString()));
}
await writer.DisposeAsync().ConfigureAwait(false);
await WaitForConditionOrThrow(() => records.Count == 5).ConfigureAwait(false);
sub.Dispose();
Assert.Equal(5, records.Count);
}
public EventStoreSettings(MemstateSettings settings)
: base(settings, ConfigurationKey)
{
Ensure.NotNull(settings, nameof(settings));
_memstateSettings = settings;
}
public async Task Smoke(MemstateSettings settings)
{
const int NumRecords = 100;
settings.LoggerFactory.AddProvider(new TestOutputLoggingProvider(_log));
settings.StreamName = _randomStreamName;
var builder = new EngineBuilder(settings);
var engine = builder.Build <List <string> >();
foreach (var number in Enumerable.Range(1, NumRecords))
{
var command = new AddStringCommand(number.ToString());
var count = await engine.ExecuteAsync(command).ConfigureAwait(false);
Assert.Equal(number, count);
}
await engine.DisposeAsync().ConfigureAwait(false);
engine = builder.Build <List <string> >();
var strings = await engine.ExecuteAsync(new GetStringsQuery()).ConfigureAwait(false);
Assert.Equal(NumRecords, strings.Count);
await engine.DisposeAsync().ConfigureAwait(false);
}
public async Task Start(string[] arguments)
{
Settings = new MemstateSettings(arguments);
Settings.WithRandomSuffixAppendedToStreamName();
Settings.LoggerFactory.AddConsole((category, level) => level > LogLevel.Debug);
Logger = Settings.CreateLogger <Benchmark>();
Engine = new EngineBuilder(Settings).Build <KeyValueStore <int> >();
var totals = new List <TimeSpan>(Runs);
for (var run = 0; run < Runs; run++)
{
Logger.LogInformation($"Run {run + 1}");
var stopwatch = Stopwatch.StartNew();
await Run();
stopwatch.Stop();
totals.Add(stopwatch.Elapsed);
await Total(stopwatch.Elapsed);
}
await Engine.DisposeAsync();
await Totals(totals);
Done?.Invoke(this, EventArgs.Empty);
}
public async Task MapsToCommand()
{
//Arrange
var settings = new MemstateSettings();
settings.FileSystem = new InMemoryFileSystem();
var storageProvider = settings.CreateStorageProvider();
var builder = new EngineBuilder(settings, storageProvider);
var engine = builder.Build <ITestModel>(new TestModel());
var client = new LocalClient <ITestModel>(engine);
var proxy = client.GetDispatchProxy();
//Act
proxy.SetCustomer(new Customer());
//release the lock on the journal
await engine.DisposeAsync();
var journalEntry = storageProvider.CreateJournalReader().GetRecords().FirstOrDefault();
// If MapTo is correct, a SetCustomerCommand will be written to the journal
// if not, then a ProxyCommand will be written
Assert.NotNull(journalEntry);
Assert.IsInstanceOf <SetCustomerCommand>(journalEntry.Command);
}
public EventStoreProvider(MemstateSettings memstateSettings)
{
_memstateSettings = memstateSettings;
_eventStoreSettings = new EventStoreSettings(memstateSettings);
_connection = EventStoreConnection.Create(_eventStoreSettings.ConnectionString);
_connection.ConnectAsync().Wait();
}
public EventStoreReader(MemstateSettings config, EventStoreSettings eventStoreSettings, IEventStoreConnection connection)
{
_logger = config.CreateLogger <EventStoreReader>();
_connection = connection;
_serializer = config.Serializers.Create(eventStoreSettings.Serializer, config);
_streamName = eventStoreSettings.StreamName;
_eventsPerSlice = eventStoreSettings.EventsPerSlice;
}
private static MemstateServer <T> CreateServer <T>(MemstateSettings settings, T model) where T : class
{
var engine = new EngineBuilder(settings).Build(model);
var server = new MemstateServer <T>(settings, engine);
return(server);
}
public void PasswordFromArgumentsOverridesConnectionString()
{
var expected = Guid.NewGuid().ToString();
var settings = new MemstateSettings("--Memstate:StorageProviders:Postgresql:Password", expected);
var pgSettings = new PostgresqlSettings(settings);
Assert.Equal(expected, pgSettings.Password);
}
private void Configure(MemstateSettings settings)
{
var logProvider = new TestOutputLoggingProvider(_log);
logProvider.MinimumLogLevel = LogLevel.Information;
settings.LoggerFactory.AddProvider(logProvider);
settings.StreamName = _randomStreamName;
}
private static IEnumerable <ISerializer> Serializers()
{
var settings = new MemstateSettings();
yield return(new WireSerializerAdapter(settings));
yield return(new JsonSerializerAdapter(settings));
}
public void SetUp()
{
_settings = new MemstateSettings();
_settings.WithInmemoryStorage();
_client = new LocalClient <UsersModel>(() => new UsersModel(), _settings);
}
public ProxyTest()
{
var config = new MemstateSettings().WithInmemoryStorage();
ITestModel model = new TestModel();
_engine = new EngineBuilder(config).Build(model);
_proxy = new LocalClient <ITestModel>(_engine).GetDispatchProxy();
}
public ProxyOverloadingTests()
{
var settings = new MemstateSettings().WithInmemoryStorage();
var storageProvider = settings.CreateStorageProvider();
var engine = new EngineBuilder(settings, storageProvider).Build <ModelWithOverloads>();
var client = new LocalClient <ModelWithOverloads>(engine);
_db = client.GetDispatchProxy();
}
public void KernelCanExecuteCommand()
{
var config = new MemstateSettings();
var model = new List <string>();
Kernel k = new Kernel(config, model);
var numStrings = (int)k.Execute(new AddStringCommand(string.Empty), e => { });
Assert.AreEqual(1, numStrings);
}
public void Setup()
{
MemstateSettings config = new MemstateSettings();
config.FileSystem = new InMemoryFileSystem();
IKeyValueStore<int> model = new KeyValueStore<int>();
var engine = new EngineBuilder(config).Build(model);
var client = new LocalClient<IKeyValueStore<int>>(engine);
_keyValueStore = client.GetDispatchProxy();
}
public EventStoreWriter(MemstateSettings settings, IEventStoreConnection connection)
: base(settings)
{
_connection = connection;
_logger = settings.CreateLogger <EventStoreWriter>();
var eventStoreSettings = new EventStoreSettings(settings);
_serializer = eventStoreSettings.CreateSerializer();
_streamName = eventStoreSettings.StreamName;
}
public EventStoreSubscriptionSource(MemstateSettings settings, IEventStoreConnection connection)
{
_logger = settings.CreateLogger <EventStoreSubscriptionSource>();
_memstateSettings = settings;
_connection = connection;
var eventStoreSettings = new EventStoreSettings(settings);
_serializer = eventStoreSettings.CreateSerializer();
_streamName = eventStoreSettings.StreamName;
}
public void Test1()
{
var config = new MemstateSettings();
var model = new List <string>();
Kernel k = new Kernel(config, model);
var numStrings = (int)k.Execute(new AddStringCommand(string.Empty), e => { });
Assert.Equal(1, numStrings);
_log.WriteLine("hello test");
}
