public TransactionalStateStorageProviderWrapper(IGrainStorage grainStorage, IGrainActivationContext context, ILoggerFactory loggerFactory)
{
this.grainStorage = grainStorage;
this.context = context;
this.loggerFactory = loggerFactory;
this.stateStorages = new ConcurrentDictionary <string, IStorage <TransactionalStateRecord <TState> > >();
}
public IStorage <TGrainState> GetStorage <TGrainState>(Grain grain) where TGrainState : new()
{
IGrainStorage grainStorage = grain.GetGrainStorage(ServiceProvider);
string grainTypeName = grain.GetType().FullName;
return(new StateStorageBridge <TGrainState>(grainTypeName, grain.GrainReference, grainStorage, this.loggerFactory));
}
public GrainStorageFixture()
{
var services = new ServiceCollection();
services
// Entity framework
.AddEntityFrameworkInMemoryDatabase()
.AddDbContextPool <TestDbContext>(builder =>
{
builder.UseInMemoryDatabase(Guid.NewGuid().ToString());
})
// Orleans stuff
.AddSingleton <ITypeResolver, TypeResolver>()
.ConfigureGrainStorageOptions <TestDbContext, ConfiguredGrainWithCustomGuidKey,
ConfiguredEntityWithCustomGuidKey>(
options =>
{
options
.UseKey(entity => entity.CustomKey);
})
// Storage
.AddEfGrainStorage <TestDbContext>()
.AddSingleton <IGrainStorage, EntityFrameworkGrainStorage <TestDbContext> >()
.AddSingleton <IGrainStorageConvention, TestGrainStorageConvention>()
.AddSingleton <IEntityTypeResolver, TestEntityTypeResolver>()
.ConfigureGrainStorageOptions <TestDbContext, ConfiguredGrainWithCustomGuidKey2,
ConfiguredEntityWithCustomGuidKey>(
options => options
.UseKey(entity => entity.CustomKey)
.UseKeyExt(entity => entity.CustomKeyExt))
.ConfigureGrainStorageOptions <TestDbContext, InvalidConfiguredGrainWithGuidKey,
InvalidConfiguredEntityWithCustomGuidKey>(
options => options
.UseKey(entity => entity.CustomKey)
.UseKeyExt(entity => entity.CustomKeyExt))
.Configure <GrainStorageConventionOptions>(options =>
{
options.DefaultGrainKeyPropertyName = nameof(EntityWithGuidKey.Id);
options.DefaultGrainKeyExtPropertyName = nameof(EntityWithGuidKey.KeyExt);
options.DefaultPersistenceCheckPropertyName = nameof(EntityWithGuidKey.IsPersisted);
});
ServiceProvider = services.BuildServiceProvider();
Storage = ServiceProvider.GetRequiredService <IGrainStorage>();
using (IServiceScope scope = ServiceProvider.CreateScope())
{
var context = scope.ServiceProvider.GetRequiredService <TestDbContext>();
// this is required to make sure data are seeded
context.Database.EnsureCreated();
}
}
public StateStorageBridge(string name, GrainReference grainRef, IGrainStorage store, ILoggerFactory loggerFactory)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (grainRef == null)
{
throw new ArgumentNullException(nameof(grainRef));
}
if (store == null)
{
throw new ArgumentNullException(nameof(store));
}
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
this.logger = loggerFactory.CreateLogger(store.GetType().FullName);
this.name = name;
this.grainRef = grainRef;
this.store = store;
this.grainState = new GrainState <TState>(new TState());
}
private async Task Test_PersistenceProvider_Read(string grainTypeName, IGrainStorage store,
GrainState <TestStoreGrainState> grainState = null, GrainId grainId = default)
{
var reference = (GrainReference)this.fixture.InternalGrainFactory.GetGrain(grainId.IsDefault ? (GrainId)LegacyGrainId.NewId() : grainId);
if (grainState == null)
{
grainState = new GrainState <TestStoreGrainState>(new TestStoreGrainState());
}
var storedGrainState = new GrainState <TestStoreGrainState>(new TestStoreGrainState());
Stopwatch sw = new Stopwatch();
sw.Start();
await store.ReadStateAsync(grainTypeName, reference, storedGrainState);
TimeSpan readTime = sw.Elapsed;
this.output.WriteLine("{0} - Read time = {1}", store.GetType().FullName, readTime);
var storedState = storedGrainState.State;
Assert.Equal(grainState.State.A, storedState.A);
Assert.Equal(grainState.State.B, storedState.B);
Assert.Equal(grainState.State.C, storedState.C);
}
public TransactionalStateStorageProviderWrapper(IGrainStorage grainStorage, IGrainActivationContext context)
{
this.grainStorage = grainStorage;
this.context = context;
this.loggerFactory = context.ActivationServices.GetRequiredService <ILoggerFactory>();
this.stateStorages = new ConcurrentDictionary <string, IStorage <TransactionalStateRecord <TState> > >();
}
public StateStorageBridgeActivator(string name, ClusterActorSystem system, IGrainStorage storage, ILoggerFactory loggerFactory)
{
this.name = name;
this.system = system;
this.storage = storage;
this.loggerFactory = loggerFactory;
}
public Task <string> CheckProviderType()
{
IGrainStorage grainStorage = this.GetGrainStorage(this.ServiceProvider);
Assert.NotNull(grainStorage);
return(Task.FromResult(grainStorage.GetType().FullName));
}
public TransactionalStateStorageProviderWrapper(IGrainStorage grainStorage, string stateName, IGrainContext context, ILoggerFactory loggerFactory)
{
this.grainStorage = grainStorage;
this.context = context;
this.loggerFactory = loggerFactory;
this.stateName = stateName;
}
public ITransactionalStateStorage <TState> Create <TState>(string storageName)
where TState : class, new()
{
// Try to get ITransactionalStateStorage from factory
ITransactionalStateStorageFactory factory = string.IsNullOrEmpty(storageName)
? this.context.ActivationServices.GetService <ITransactionalStateStorageFactory>()
: this.context.ActivationServices.GetServiceByName <ITransactionalStateStorageFactory>(storageName);
if (factory != null)
{
return(factory.Create <TState>());
}
// Else try to get storage provider and wrap it
IGrainStorage grainStorage = string.IsNullOrEmpty(storageName)
? this.context.ActivationServices.GetService <IGrainStorage>()
: this.context.ActivationServices.GetServiceByName <IGrainStorage>(storageName);
if (grainStorage != null)
{
return(new TransactionalStateStorageProviderWrapper <TState>(grainStorage, context));
}
throw (string.IsNullOrEmpty(storageName))
? new InvalidOperationException($"No default {nameof(ITransactionalStateStorageFactory)} nor {nameof(IStorageProvider)} was found while attempting to create transactional state storage.")
: new InvalidOperationException($"No {nameof(ITransactionalStateStorageFactory)} nor {nameof(IStorageProvider)} with the name {storageName} was found while attempting to create transactional state storage.");
}
/// <summary>
/// Default constructor which creates the decorated storage provider
/// </summary>
public FaultInjectionGrainStorage(IGrainStorage realStorageProvider, string name, ILoggerFactory loggerFactory,
IGrainFactory grainFactory, FaultInjectionGrainStorageOptions faultInjectionOptions)
{
this.realStorageProvider = realStorageProvider;
this.logger = loggerFactory.CreateLogger($"{this.GetType().FullName}.{name}");
this.grainFactory = grainFactory;
this.options = faultInjectionOptions;
}
private void InstallLogViewAdaptor(
Factory <Grain, ILogConsistencyProtocolServices> protocolServicesFactory,
ILogViewAdaptorFactory factory,
IGrainStorage grainStorage)
{
// encapsulate runtime services used by consistency adaptors
ILogConsistencyProtocolServices svc = protocolServicesFactory(this);
TView state = (TView)Activator.CreateInstance(typeof(TView));
this.InstallAdaptor(factory, state, this.GetType().FullName, grainStorage, svc);
}
public IStorage <TGrainState> GetStorage <TGrainState>(IGrainContext grainContext)
{
if (grainContext is null)
{
throw new ArgumentNullException(nameof(grainContext));
}
var grainType = grainContext.GrainInstance?.GetType() ?? throw new ArgumentNullException(nameof(IGrainContext.GrainInstance));
IGrainStorage grainStorage = GrainStorageHelpers.GetGrainStorage(grainType, ServiceProvider);
string grainTypeName = grainContext.GrainInstance.GetType().FullName;
return(new StateStorageBridge <TGrainState>(grainTypeName, grainContext.GrainReference, grainStorage, this.loggerFactory));
}
public GrainStorageFixture()
{
var services = new ServiceCollection();
services
.AddEntityFrameworkInMemoryDatabase()
.AddDbContextPool <TestDbContext>(builder =>
{
builder.UseInMemoryDatabase(Guid.NewGuid().ToString());
})
.AddSingleton <IGrainStorageConvention, GrainStorageConvention>()
// Simple key grains with default key properties on state model
// should work out of the box without configuration.
.ConfigureGrainStorageOptions <TestDbContext, ConfiguredGrainWithCustomGuidKey,
ConfiguredEntityWithCustomGuidKey>(
options => options
.UseKey(entity => entity.CustomKey))
.ConfigureGrainStorageOptions <TestDbContext, ConfiguredGrainWithCustomGuidKey2,
ConfiguredEntityWithCustomGuidKey>(
options => options
.UseKey(entity => entity.CustomKey)
.UseKeyExt(entity => entity.CustomKeyExt))
.ConfigureGrainStorageOptions <TestDbContext, InvalidConfiguredGrainWithGuidKey,
InvalidConfiguredEntityWithCustomGuidKey>(
options => options
.UseKey(entity => entity.CustomKey)
.UseKeyExt(entity => entity.CustomKeyExt))
.AddSingleton <IGrainStorage, EntityFrameworkGrainStorage <TestDbContext> >()
.Configure <GrainStorageConventionOptions>(options =>
{
options.DefaultGrainKeyPropertyName = nameof(EntityWithGuidKey.Id);
options.DefaultGrainKeyExtPropertyName = nameof(EntityWithGuidKey.KeyExt);
options.DefaultPersistenceCheckPropertyName = nameof(EntityWithGuidKey.IsPersisted);
});
ServiceProvider = services.BuildServiceProvider();
Storage = ServiceProvider.GetRequiredService <IGrainStorage>();
using (IServiceScope scope = ServiceProvider.CreateScope())
{
var context = scope.ServiceProvider.GetRequiredService <TestDbContext>();
// this is required to make sure data are seeded
context.Database.EnsureCreated();
}
}
/// <summary>
/// Aquire the storage provider associated with the grain type.
/// </summary>
/// <returns></returns>
public static IGrainStorage GetGrainStorage(this Type grainType, IServiceProvider services)
{
var attr = grainType.GetCustomAttributes <StorageProviderAttribute>(true).FirstOrDefault();
IGrainStorage storageProvider = attr != null
? services.GetServiceByName <IGrainStorage>(attr.ProviderName)
: services.GetService <IGrainStorage>();
if (storageProvider == null)
{
ThrowMissingProviderException(grainType, attr?.ProviderName);
}
return(storageProvider);
}
private Task OnSetupState(CancellationToken ct)
{
if (ct.IsCancellationRequested)
{
return(Task.CompletedTask);
}
IGrainActivationContext activationContext = this.ServiceProvider.GetRequiredService <IGrainActivationContext>();
Factory <Grain, IMultiClusterRegistrationStrategy, ILogConsistencyProtocolServices> protocolServicesFactory = this.ServiceProvider.GetRequiredService <Factory <Grain, IMultiClusterRegistrationStrategy, ILogConsistencyProtocolServices> >();
ILogViewAdaptorFactory consistencyProvider = SetupLogConsistencyProvider(activationContext);
IGrainStorage grainStorage = consistencyProvider.UsesStorageProvider ? this.GetGrainStorage(this.ServiceProvider) : null;
InstallLogViewAdaptor(activationContext.RegistrationStrategy, protocolServicesFactory, consistencyProvider, grainStorage);
return(Task.CompletedTask);
}
private void EnsureGrainStorage()
{
if (_grainStorage == null)
{
var implementation = TypeCodeMapper.GetImplementation(this.SiloIndexManager.GrainTypeResolver, typeof(V));
if (implementation == null || (_grainClassName = implementation.GrainClass) == null ||
!this.SiloIndexManager.CachedTypeResolver.TryResolveType(_grainClassName, out Type grainClassType))
{
throw new IndexException($"The grain implementation class {implementation.GrainClass} for grain" +
" interface {IndexUtils.GetFullTypeName(typeof(V))} was not resolved.");
}
_grainStorage = grainClassType.GetGrainStorage(this.SiloIndexManager.ServiceProvider);
}
}
private Task OnSetupState(CancellationToken ct)
{
if (ct.IsCancellationRequested)
{
return(Task.CompletedTask);
}
IGrainContextAccessor grainContextAccessor = this.ServiceProvider.GetRequiredService <IGrainContextAccessor>();
Factory <IGrainContext, ILogConsistencyProtocolServices> protocolServicesFactory = this.ServiceProvider.GetRequiredService <Factory <IGrainContext, ILogConsistencyProtocolServices> >();
var grainContext = grainContextAccessor.GrainContext;
ILogViewAdaptorFactory consistencyProvider = SetupLogConsistencyProvider(grainContext);
IGrainStorage grainStorage = consistencyProvider.UsesStorageProvider ? GrainStorageHelpers.GetGrainStorage(grainContext?.GrainInstance.GetType(), this.ServiceProvider) : null;
InstallLogViewAdaptor(grainContext, protocolServicesFactory, consistencyProvider, grainStorage);
return(Task.CompletedTask);
}
private async Task EnsureStorage()
{
if (this.StorageProvider == null)
{
using (await _writeLock.LockAsync())
{
if (this.StorageProvider == null) // Make sure another thread didn't get it
{
var readGrainReference = this._recoveryGrainReference ?? _lazyParent.Value;
this.StorageProvider = typeof(IndexWorkflowQueueGrainService).GetGrainStorage(this.SiloIndexManager.ServiceProvider);
await this.StorageProvider.ReadStateAsync(_grainTypeName, readGrainReference, this.queueState);
}
}
}
}
public IPersistentState <TState> Create <TState>(IGrainContext context, IPersistentStateConfiguration cfg)
{
IGrainStorage storageProvider = !string.IsNullOrWhiteSpace(cfg.StorageName)
? context.ActivationServices.GetServiceByName <IGrainStorage>(cfg.StorageName)
: context.ActivationServices.GetService <IGrainStorage>();
if (storageProvider == null)
{
ThrowMissingProviderException(context, cfg);
}
string fullStateName = GetFullStateName(context, cfg);
var bridge = new PersistentStateBridge <TState>(fullStateName, context, storageProvider);
bridge.Participate(context.ObservableLifecycle);
return(bridge);
}
private void EnsureGrainStorage()
{
if (_grainStorage == null)
{
var implementation = TypeCodeMapper.GetImplementation(this.SiloIndexManager.GrainTypeResolver, typeof(V));
if (implementation == null || (grainImplClass = implementation.GrainClass) == null ||
!this.SiloIndexManager.CachedTypeResolver.TryResolveType(grainImplClass, out Type implType))
{
throw new IndexException($"The grain implementation class {implementation.GrainClass} for grain" +
" interface {IndexUtils.GetFullTypeName(typeof(V))} was not resolved.");
}
_grainStorage = implType.GetGrainStorage(this.SiloIndexManager.ServiceProvider);
bool isFaultTolerant = ApplicationPartsIndexableGrainLoader.IsSubclassOfRawGenericType(typeof(IndexableGrain <,>), implType);
_indexedFieldPrefix = isFaultTolerant ? "UserState." : string.Empty;
}
}
public ILogViewAdaptor <TLogView, TLogEntry> MakeLogViewAdaptor <TLogView, TLogEntry>(
ILogViewAdaptorHost <TLogView, TLogEntry> hostGrain,
TLogView initialState,
string grainTypeName,
IGrainStorage grainStorage,
ILogConsistencyProtocolServices services)
where TLogView : class, new()
where TLogEntry : class
{
return(new LogViewAdaptor <TLogView, TLogEntry>(
hostGrain,
initialState,
grainStorage,
grainTypeName,
_snapshotStrategy,
services,
_options.UseIndependentEventStorage,
_eventStorage));
}
public GrainStorageFixture()
{
var services = new ServiceCollection();
services
.AddLogging(logging => logging
.AddConsole()
.SetMinimumLevel(LogLevel.Trace)
)
// Entity framework
.AddEntityFrameworkInMemoryDatabase()
.AddDbContextPool <TestDbContext>(builder =>
{
builder.UseInMemoryDatabase(Guid.NewGuid().ToString());
builder.EnableSensitiveDataLogging();
})
// Orleans stuff
.AddSingleton <ITypeResolver, TypeResolver>()
// Storage
.AddEfGrainStorage <TestDbContext>()
.AddSingleton <IGrainStorage, EntityFrameworkGrainStorage <TestDbContext> >()
.AddSingleton <IGrainStorageConvention, TestGrainStorageConvention>()
.AddSingleton <IEntityTypeResolver, TestEntityTypeResolver>();
ConfigureGrainStorage(services);
ServiceProvider = services.BuildServiceProvider();
Storage = ServiceProvider.GetRequiredService <IGrainStorage>();
using (IServiceScope scope = ServiceProvider.CreateScope())
{
var context = scope.ServiceProvider.GetRequiredService <TestDbContext>();
// this is required to make sure data are seeded
context.Database.EnsureCreated();
}
}
internal IndexWorkflowQueueBase(SiloIndexManager siloIndexManager, Type grainInterfaceType, int queueSequenceNumber, SiloAddress silo,
bool isDefinedAsFaultTolerantGrain, Func <GrainReference> parentFunc)
{
queueState = new IndexWorkflowQueueState(silo);
_grainInterfaceType = grainInterfaceType;
_queueSeqNum = queueSequenceNumber;
_workflowRecordsTail = null;
__grainStorage = null;
__handler = null;
_isHandlerWorkerIdle = 1;
_isDefinedAsFaultTolerantGrain = isDefinedAsFaultTolerantGrain;
_writeLock = new AsyncLock();
_writeRequestIdGen = 0;
_pendingWriteRequests = new HashSet <int>();
_silo = silo;
SiloIndexManager = siloIndexManager;
_lazyParent = new Lazy <GrainReference>(parentFunc, true);
}
public LogViewAdaptor(
ILogViewAdaptorHost <TLogView, TLogEntry> host,
TLogView initialState,
IGrainStorage grainStorage,
string grainTypeName,
Func <SnapshotStrategyInfo, bool> snapshotStrategy,
ILogConsistencyProtocolServices services,
bool useIndependentEventStorage,
IGrainEventStorage eventStorage)
: base(host, initialState, services)
{
_grainStorage = grainStorage;
_grainTypeName = grainTypeName;
_snapshotStrategy = snapshotStrategy;
_useIndependentEventStorage = useIndependentEventStorage;
if (useIndependentEventStorage)
{
_eventStorage = eventStorage
?? throw new ArgumentNullException(nameof(eventStorage),
"Must set eventStorage when useIndependentEventStorage is true");
}
}
public GrainStorageUpdateTests(GrainStorageFixture storageFixture)
{
_storage = storageFixture.Storage;
_serviceProvider = storageFixture.ServiceProvider;
}
/// <summary>
/// Make log view adaptor
/// </summary>
/// <typeparam name="TView">The type of the view</typeparam>
/// <typeparam name="TEntry">The type of the log entries</typeparam>
/// <param name="hostGrain">The grain that is hosting this adaptor</param>
/// <param name="initialState">The initial state for this view</param>
/// <param name="grainTypeName">The type name of the grain</param>
/// <param name="grainStorage">Storage provider</param>
/// <param name="services">Runtime services for multi-cluster coherence protocols</param>
public ILogViewAdaptor <TView, TEntry> MakeLogViewAdaptor <TView, TEntry>(ILogViewAdaptorHost <TView, TEntry> hostGrain, TView initialState, string grainTypeName, IGrainStorage grainStorage, ILogConsistencyProtocolServices services)
where TView : class, new()
where TEntry : class
{
return(new LogViewAdaptor <TView, TEntry>(hostGrain, initialState, grainStorage, grainTypeName, services));
}
/// <summary> /// called right after grain construction to install the log view adaptor /// </summary> /// <param name="factory"> The adaptor factory to use </param> /// <param name="state"> The initial state of the view </param> /// <param name="grainTypeName"> The type name of the grain </param> /// <param name="grainStorage"> The grain storage, if needed </param> /// <param name="services"> Protocol services </param> protected abstract void InstallAdaptor(ILogViewAdaptorFactory factory, object state, string grainTypeName, IGrainStorage grainStorage, ILogConsistencyProtocolServices services);
private async Task <GrainState <TestStoreGrainState> > Test_PersistenceProvider_WriteClearRead(string grainTypeName,
IGrainStorage store, GrainState <TestStoreGrainState> grainState = null, GrainId grainId = default)
{
GrainReference reference = (GrainReference)this.fixture.InternalGrainFactory.GetGrain(grainId.IsDefault ? (GrainId)LegacyGrainId.NewId() : grainId);
if (grainState == null)
{
grainState = TestStoreGrainState.NewRandomState();
}
Stopwatch sw = new Stopwatch();
sw.Start();
await store.WriteStateAsync(grainTypeName, reference, grainState);
TimeSpan writeTime = sw.Elapsed;
sw.Restart();
await store.ClearStateAsync(grainTypeName, reference, grainState);
var storedGrainState = new GrainState <TestStoreGrainState>
{
State = new TestStoreGrainState()
};
await store.ReadStateAsync(grainTypeName, reference, storedGrainState);
TimeSpan readTime = sw.Elapsed;
this.output.WriteLine("{0} - Write time = {1} Read time = {2}", store.GetType().FullName, writeTime, readTime);
Assert.NotNull(storedGrainState.State);
Assert.Equal(default(string), storedGrainState.State.A);
Assert.Equal(default(int), storedGrainState.State.B);
Assert.Equal(default(long), storedGrainState.State.C);
return(storedGrainState);
}
public PersistentStateBridge(string fullStateName, IGrainContext context, IGrainStorage storageProvider)
{
this.fullStateName = fullStateName;
this.context = context;
this.storageProvider = storageProvider;
}
