public FileJournalWriter(MemstateSettings settings, string fileName, long nextRecord)
: base(settings)
{
_nextRecord = nextRecord;
_journalStream = settings.FileSystem.OpenAppend(fileName);
_serializer = settings.CreateSerializer();
}
public EngineBuilder(MemstateSettings settings, StorageProvider storageProvider = null)
{
_settings = settings;
_storageProvider = storageProvider ?? settings.CreateStorageProvider();
_storageProvider.Initialize();
}
public Kernel(MemstateSettings config, object model)
{
_logger = config.CreateLogger <Kernel>();
_model = model;
_lock = new ReaderWriterLockSlim(LockRecursionPolicy.NoRecursion);
_logger.LogInformation("Created Kernel");
}
public FileJournalWriter(MemstateSettings settings, string fileName, long nextRecord)
: base(settings)
{
_nextRecord = nextRecord;
_journalStream = File.Open(fileName, FileMode.Append, FileAccess.Write, FileShare.None);
_serializer = settings.CreateSerializer();
}
public static MemstateSettings WithRandomSuffixAppendedToStreamName(this MemstateSettings settings)
{
var randomPart = Guid.NewGuid().ToString("N").Substring(0, 10);
settings.StreamName += randomPart;
return(settings);
}
public MemstateClient(MemstateSettings config)
{
_config = config;
_serializer = config.CreateSerializer();
_pendingRequests = new Dictionary <Guid, TaskCompletionSource <Message> >();
_logger = _config.LoggerFactory.CreateLogger <MemstateClient <TModel> >();
_cancellationSource = new CancellationTokenSource();
_events = new ClientEvents();
_events.SubscriptionAdded += async(type, filters) =>
{
var request = new SubscribeRequest(type, filters.ToArray());
await SendAndReceive(request);
};
_events.SubscriptionRemoved += async type =>
{
var request = new UnsubscribeRequest(type);
await SendAndReceive(request);
};
_events.GlobalFilterAdded += async filter =>
{
var request = new FilterRequest(filter);
await SendAndReceive(request);
};
}
public FileJournalWriter(MemstateSettings settings, string fileName, long nextRecord, int pageSize)
: base(settings)
{
_pageSize = pageSize;
_nextRecord = nextRecord;
_serializer = settings.CreateSerializer();
_writtenRecords = (int)(nextRecord % _pageSize);
_settings = settings;
_fileName = fileName;
if (_fileName.Contains("{0}"))
{
var i = 0;
while (settings.FileSystem.Exists(string.Format(_fileName, i++)))
{
}
_fileNameIndex = i;
}
else
{
_staticFileName = true;
}
}
public EngineBuilder(MemstateSettings settings, StorageProvider storageProvider = null)
{
_settings = settings;
_storageProvider = storageProvider ?? settings.CreateStorageProvider();
// TODO: Figure out what to do if initialization has already been executed.
_storageProvider.Initialize();
}
protected Settings(MemstateSettings parent, string configurationKey)
{
Ensure.NotNull(parent, nameof(parent));
Ensure.NotNullOrEmpty(configurationKey, nameof(configurationKey));
Memstate = parent;
Configuration = parent.Configuration.GetSection(configurationKey);
Configuration.Bind(this);
}
public MemstateClient(MemstateSettings config)
{
_config = config;
_serializer = config.CreateSerializer();
_pendingRequests = new Dictionary <Guid, TaskCompletionSource <Message> >();
_logger = _config.LoggerFactory.CreateLogger <MemstateClient <TModel> >();
_cancellationSource = new CancellationTokenSource();
}
public Batcher(MemstateSettings config, Action <IEnumerable <T> > batchHandler)
{
_logger = config.CreateLogger <Batcher <T> >();
_batchHandler = batchHandler;
_maxBatchSize = config.MaxBatchSize;
_items = new BlockingCollection <T>(config.MaxBatchQueueLength);
_batchTask = new Task(ProcessItems, TaskCreationOptions.LongRunning);
_batchTask.Start();
}
public Engine(
MemstateSettings config,
TModel model,
IJournalSubscriptionSource subscriptionSource,
IJournalWriter journalWriter,
long nextRecord)
{
_lastRecordNumber = nextRecord - 1;
_logger = config.CreateLogger <Engine <TModel> >();
_kernel = new Kernel(config, model);
_journalWriter = journalWriter;
_pendingLocalCommands = new ConcurrentDictionary <Guid, TaskCompletionSource <object> >();
_commandSubscription = subscriptionSource.Subscribe(nextRecord, ApplyRecord);
}
public Engine(
MemstateSettings settings,
TModel model,
IJournalSubscriptionSource subscriptionSource,
IJournalWriter journalWriter,
long nextRecord)
{
_lastRecordNumber = nextRecord - 1;
_logger = settings.CreateLogger <Engine <TModel> >();
_kernel = new Kernel(settings, model);
_settings = settings;
_journalWriter = journalWriter;
_pendingLocalCommands = new ConcurrentDictionary <Guid, TaskCompletionSource <object> >();
_commandSubscription = subscriptionSource.Subscribe(nextRecord, OnRecordReceived);
_metrics = new EngineMetrics(settings);
}
public EngineMetrics(MemstateSettings settings)
{
_settings = settings;
}
public LocalClient(Func <TModel> creator, MemstateSettings settings)
: this(new EngineBuilder(settings).Build(creator()))
{
}
public KernelMetrics(MemstateSettings settings)
{
_settings = settings;
}
public static MemstateSettings WithInmemoryStorage(this MemstateSettings settings)
{
settings.FileSystem = new InMemoryFileSystem();
return(settings);
}
public InMemoryStorageProvider(MemstateSettings settings, long nextRecord = 0)
{
_batchingLogger = new Batcher <Command>(settings, OnCommandBatch);
_subscriptions = new Dictionary <Guid, JournalSubscription>();
_nextRecord = nextRecord;
}
public static MemstateSettings WithInmemoryStorage(this MemstateSettings settings)
{
settings.StorageProvider = typeof(InMemoryStorageProvider).FullName;
return(settings);
}
public FileJournalReader(string fileName, MemstateSettings settings)
{
_fileName = fileName;
_settings = settings;
_serializer = settings.CreateSerializer();
}
public static Task <Engine <T> > StartAsync <T>(MemstateSettings settings = null) where T : class, new()
{
settings = settings ?? new MemstateSettings();
return(new EngineBuilder(settings).BuildAsync <T>());
}
protected BatchingJournalWriter(MemstateSettings config)
{
Ensure.NotNull(config, nameof(config));
_batcher = new Batcher <Command>(config, OnCommandBatch);
}
private static T InstanceFromTypeName(string typeName, MemstateSettings settings)
{
var type = Type.GetType(typeName, throwOnError: true, ignoreCase: true);
return((T)Activator.CreateInstance(type, settings));
}
public T Create(string providerName, MemstateSettings settings)
{
return(RegisteredProviders.TryGetValue(providerName, out var providerConstructor)
? providerConstructor.Invoke(settings)
: InstanceFromTypeName(providerName, settings));
}
public InMemoryStorageProvider(MemstateSettings settings) : this(settings, 0)
{
}
public FileJournalReader(string fileName, MemstateSettings settings)
{
_journalStream = settings.FileSystem.OpenRead(fileName);
_serializer = settings.CreateSerializer();
}
public FileStorageProvider(MemstateSettings settings)
{
_settings = settings;
_fileStorageSettings = new FileStorageSettings(settings);
}
