private async Task TestReadAsync <TGrain, TState, TKey>()
where TState : Entity <TKey>, new()
where TGrain : Grain <TState>
{
GrainState <TState> grainState = Internal.Utils.CreateAndStoreGrainState <TState>(_serviceProvider);
TestGrainReference grainRef
= TestGrainReference.Create(grainState.State);
grainState.State = null;
await _storage.ReadStateAsync(typeof(TGrain).FullName,
grainRef,
grainState
);
Internal.Utils.AssertEntityEqualityVsDb(_serviceProvider, grainState.State);
}
private async Task TestClearAsync <TGrain, TState, TKey>()
where TState : Entity <TKey>, new()
where TGrain : Grain <TState>
{
GrainState <TState> grainState = Internal.Utils.CreateAndStoreGrainState <TState>(_serviceProvider);
TestGrainReference grainRef
= TestGrainReference.Create(grainState.State);
await _storage.ClearStateAsync(typeof(TGrain).FullName,
grainRef,
grainState
);
var actual = Internal.Utils.FetchEntityFromDb(_serviceProvider, grainState.State);
Assert.Null(actual);
}
public async Task SinglePropertyWrite()
{
GrainState <EntityWithIntegerKey> grainState =
Internal.Utils.CreateAndStoreGrainState <EntityWithIntegerKey>(_serviceProvider);
grainState.State.Title = "Should get updated";
grainState.State.KeyExt = "Should not get updated";
TestGrainReference grainRef
= TestGrainReference.Create(grainState.State);
GrainStorageContext <EntityWithIntegerKey> .ConfigureEntryState(
entry => entry
.Property(e => e.Title)
.IsModified = true
);
await _storage.WriteStateAsync(typeof(GrainWithIntegerKey).FullName,
grainRef,
grainState);
var stored = (EntityWithIntegerKey)
Internal.Utils.FetchEntityFromDb(_serviceProvider, grainState.State);
Assert.Equal("Should get updated", stored?.Title);
Assert.NotEqual("Should not get updated", stored?.KeyExt);
GrainStorageContext <EntityWithIntegerKey> .Clear();
// Future updates should update the whole object if not configured
await _storage.WriteStateAsync(typeof(GrainWithIntegerKey).FullName,
grainRef,
grainState);
stored = (EntityWithIntegerKey)
Internal.Utils.FetchEntityFromDb(_serviceProvider, grainState.State);
Assert.Equal(stored, grainState.State);
}
public async Task WriteWithETagSuccess()
{
GrainState <EntityWithIntegerKeyWithEtag> grainState =
Internal.Utils.CreateAndStoreGrainState <EntityWithIntegerKeyWithEtag>(_serviceProvider);
TestGrainReference grainRef
= TestGrainReference.Create(grainState.State);
grainState.State.Title = "Updated";
await _storage.WriteStateAsync(typeof(GrainWithIntegerKeyWithEtag).FullName,
grainRef,
grainState);
string expected = BitConverter.ToString(grainState.State.ETag)
.Replace("-", string.Empty);
Assert.Equal(expected, grainState.ETag);
}
/// <summary>
/// Serialize to Azure storage format in either binary or JSON format.
/// </summary>
/// <param name="grainState">The grain state data to be serialized</param>
/// <param name="entity">The Azure table entity the data should be stored in</param>
/// <remarks>
/// See:
/// http://msdn.microsoft.com/en-us/library/system.web.script.serialization.javascriptserializer.aspx
/// for more on the JSON serializer.
/// </remarks>
internal void ConvertToStorageFormat(GrainState grainState, GrainStateEntity entity)
{
// Dehydrate
var dataValues = grainState.AsDictionary();
int dataSize;
if (useJsonFormat)
{
// http://james.newtonking.com/json/help/index.html?topic=html/T_Newtonsoft_Json_JsonConvert.htm
string data = Newtonsoft.Json.JsonConvert.SerializeObject(dataValues, jsonSettings);
if (Log.IsVerbose3)
{
Log.Verbose3("Writing JSON data size = {0} for grain id = Partition={1} / Row={2}",
data.Length, entity.PartitionKey, entity.RowKey);
}
dataSize = data.Length;
entity.StringData = data;
}
else
{
// Convert to binary format
byte[] data = SerializationManager.SerializeToByteArray(dataValues);
if (Log.IsVerbose3)
{
Log.Verbose3("Writing binary data size = {0} for grain id = Partition={1} / Row={2}",
data.Length, entity.PartitionKey, entity.RowKey);
}
dataSize = data.Length;
entity.Data = data;
}
if (dataSize > MAX_DATA_SIZE)
{
var msg = string.Format("Data too large to write to Azure table. Size={0} MaxSize={1}", dataSize, MAX_DATA_SIZE);
Log.Error(0, msg);
throw new ArgumentOutOfRangeException("GrainState.Size", msg);
}
}
public async Task ClearStateAsync(string grainType, GrainReference grainId, GrainState grainState)
{
try
{
var blobName = GetBlobName(grainType, grainId);
var blob = container.GetBlockBlobReference(blobName);
await
blob.DeleteIfExistsAsync(
DeleteSnapshotsOption.None,
AccessCondition.GenerateIfMatchCondition(grainState.Etag),
null,
null);
grainState.Etag = blob.Properties.ETag;
}
catch (Exception ex)
{
Log.Error(0, ex.ToString());
}
}
public StateStorageBridge(string name, GrainReference grainRef, IStorageProvider store)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
if (grainRef == null)
{
throw new ArgumentNullException(nameof(grainRef));
}
if (store == null)
{
throw new ArgumentNullException(nameof(store));
}
this.name = name;
this.grainRef = grainRef;
this.store = store;
this.grainState = new GrainState <TState>(new TState());
}
/// <summary>
/// Writes to storage, clears and reads back and asserts both the version and the state.
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="grainReference">The grain reference as would be given by Orleans.</param>
/// <param name="grainState">The grain state the grain would hold and Orleans pass.</param>
/// <returns></returns>
internal async Task Store_WriteClearRead <T>(string grainTypeName, GrainReference grainReference, GrainState <T> grainState) where T : new()
{
//A legal situation for clearing has to be arranged by writing a state to the storage before
//clearing it. Writing and clearing both change the ETag, so they should differ.
await Storage.WriteStateAsync(grainTypeName, grainReference, grainState);
string writtenStateVersion = grainState.ETag;
await Storage.ClearStateAsync(grainTypeName, grainReference, grainState);
string clearedStateVersion = grainState.ETag;
var storedGrainState = new GrainState <T> {
State = new T()
};
await Storage.ReadStateAsync(grainTypeName, grainReference, storedGrainState);
Assert.NotEqual(writtenStateVersion, clearedStateVersion);
Assert.Equal(storedGrainState.State, Activator.CreateInstance <T>());
}
public async Task ReadStateAsync(string grainType, GrainReference grainId, GrainState grainState)
{
try
{
var blobName = GetBlobName(grainType, grainId);
var blob = container.GetBlockBlobReference(blobName);
string text;
try
{
text = await blob.DownloadTextAsync();
}
catch (StorageException exception)
{
var errorCode = exception.RequestInformation.ExtendedErrorInformation.ErrorCode;
if (errorCode == BlobErrorCodeStrings.ContainerNotFound || errorCode == BlobErrorCodeStrings.BlobNotFound)
{
return;
}
throw;
}
if (string.IsNullOrWhiteSpace(text))
{
return;
}
var data = JsonConvert.DeserializeObject(text, grainState.GetType(), settings);
var dict = ((GrainState)data).AsDictionary();
grainState.SetAll(dict);
grainState.Etag = blob.Properties.ETag;
}
catch (Exception ex)
{
Log.Error(0, ex.ToString());
throw;
}
}
private static async Task Test_PersistenceProvider_Read(string grainTypeName, IStorageProvider store)
{
GrainReference reference = GrainReference.FromGrainId(GrainId.NewId());
TestStoreGrainState state = new TestStoreGrainState();
Stopwatch sw = new Stopwatch();
var storedGrainState = new GrainState <TestStoreGrainState>
{
State = new TestStoreGrainState()
};
sw.Start();
await store.ReadStateAsync(grainTypeName, reference, storedGrainState);
TimeSpan readTime = sw.Elapsed;
Console.WriteLine("{0} - Read time = {1}", store.GetType().FullName, readTime);
var storedState = storedGrainState.State;
Assert.AreEqual(state.A, storedState.A, "A");
Assert.AreEqual(state.B, storedState.B, "B");
Assert.AreEqual(state.C, storedState.C, "C");
}
private void LoadStoredSounds()
{
if (storedState == null)
{
return;
}
Sound2[] componentsInChildren = GetComponentsInChildren <Sound2>(includeInactive: true);
foreach (Sound2 sound in componentsInChildren)
{
string fullName = sound.fullName;
SoundState soundState = storedState.GetSoundState(fullName);
GrainState grainState = storedState.GetGrainState(fullName);
if (soundState != null)
{
Deserialize(sound, soundState, pasteSample: true);
}
if (grainState != null)
{
Deserialize(sound, grainState);
}
}
}
private async Task <GrainState <TestStoreGrainState> > Test_PersistenceProvider_WriteClearRead(string grainTypeName,
IStorageProvider store, GrainState <TestStoreGrainState> grainState = null, GrainId grainId = null)
{
GrainReference reference = GrainReference.FromGrainId(grainId ?? GrainId.NewId());
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;
output.WriteLine("{0} - Write time = {1} Read time = {2}", store.GetType().FullName, writeTime, readTime);
Assert.IsNotNull(storedGrainState.State, "State");
Assert.AreEqual(default(string), storedGrainState.State.A, "A");
Assert.AreEqual(default(int), storedGrainState.State.B, "B");
Assert.AreEqual(default(long), storedGrainState.State.C, "C");
return(storedGrainState);
}
public async Task DoesNotLoadSlidingExpiredItemFromStorage()
{
// arrange
var key = Guid.NewGuid().ToString();
var grain = _fixture.PrimarySiloServiceProvider.GetRequiredService <IGrainFactory>().GetCacheGrain(key);
var storage = _fixture.PrimarySiloServiceProvider.GetRequiredServiceByName <IGrainStorage>(OutkeepProviderNames.OutkeepCache);
var reference = (GrainReference)grain;
var grainType = $"{typeof(CacheGrain).FullName},{typeof(CacheGrain).Namespace}";
var state = new GrainState <CacheGrainState>(new CacheGrainState
{
Tag = Guid.NewGuid(),
Value = Guid.NewGuid().ToByteArray(),
AbsoluteExpiration = DateTimeOffset.UtcNow.AddDays(1),
SlidingExpiration = TimeSpan.FromMinutes(1)
});
await storage.WriteStateAsync($"{grainType}.State", reference, state).ConfigureAwait(false);
var flags = new GrainState <CacheGrainFlags>(new CacheGrainFlags
{
UtcLastAccessed = DateTime.UtcNow.AddMinutes(-2)
});
await storage.WriteStateAsync($"{grainType}.Flags", reference, flags).ConfigureAwait(false);
// act
var result = await grain.GetAsync();
// assert
Assert.Equal(Guid.Empty, result.Tag);
Assert.Null(result.Value);
// act
var repeat = await grain.GetAsync();
// assert
Assert.Equal(result.Tag, repeat.Tag);
Assert.Equal(result.Value, repeat.Value);
}
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 async Task ReadStateAsyncShouldCallDataManagerReadAsync()
{
var mockDataManager = new Mock <ICouchbaseDataManager>();
var mockLogger = new Mock <ILogger <CouchbaseGrainStorage> >();
var mockSerialiser = new Mock <ISerializer>();
mockDataManager.Setup(s => s.ReadAsync(It.Is <string>(i => i == "String"), It.IsAny <string>()))
.ReturnsAsync(() => new ReadResponse {
Document = "123", ETag = "456"
}).Verifiable();
mockSerialiser.Setup(s => s.Deserialize(It.Is <string>(i => i == "123"), It.IsAny <Type>())).Returns(() => "Deserialised").Verifiable();
var sut = new CouchbaseGrainStorage(string.Empty, mockDataManager.Object, mockLogger.Object, mockSerialiser.Object);
var grainState = new GrainState <string> {
State = ""
};
await sut.ReadStateAsync(typeof(string).Name, null, grainState);
grainState.State.Should().Be("Deserialised");
grainState.ETag.Should().Be("456");
}
private void LoadOverlaySound(SoundMaster sound)
{
string fullName = sound.master.fullName;
SoundState soundState = state.GetSoundState(fullName);
GrainState grainState = state.GetGrainState(fullName);
if (soundState == null || soundState.useMaster)
{
SoundState soundState2 = main.state.GetSoundState(fullName);
if (soundState2 != null)
{
soundState = soundState2;
}
GrainState grainState2 = main.state.GetGrainState(fullName);
if (grainState2 != null)
{
grainState = grainState2;
}
}
if (soundState == null && storedState != null)
{
soundState = storedState.GetSoundState(fullName);
grainState = storedState.GetGrainState(fullName);
}
if (soundState != null)
{
Deserialize(sound, soundState, pasteSample: true);
}
else
{
sound.SetSample(sound.master.sample);
}
if (grainState != null)
{
Deserialize(sound, grainState);
}
}
public async Task WriteCustomGetterGrainState()
{
var entity = new EntityWithGuidKey();
var state = new GrainStateWrapper <EntityWithGuidKey>()
{
Value = entity
};
var grainState = new GrainState <GrainStateWrapper <EntityWithGuidKey> >()
{
State = state
};
TestGrainReference grainRef
= TestGrainReference.Create(entity);
await _storage.WriteStateAsync(typeof(GrainWithCustomStateGuidKey).FullName,
grainRef,
grainState
);
Internal.Utils.AssertEntityEqualityVsDb(
_serviceProvider, grainState.State?.Value);
}
public override async Task WriteStateAsync(string grainType, GrainReference grainReference, GrainState grainState)
{
await MakeFixedLatencyCall(() => base.WriteStateAsync(grainType, grainReference, grainState));
}
/// <summary>
/// Serialize to Azure storage format in either binary or JSON format.
/// </summary>
/// <param name="grainState">The grain state data to be serialized</param>
/// <param name="entity">The Azure table entity the data should be stored in</param>
/// <remarks>
/// See:
/// http://msdn.microsoft.com/en-us/library/system.web.script.serialization.javascriptserializer.aspx
/// for more on the JSON serializer.
/// </remarks>
internal void ConvertToStorageFormat(GrainState grainState, GrainStateEntity entity)
{
// Dehydrate
var dataValues = grainState.AsDictionary();
int dataSize;
if (useJsonFormat)
{
// http://james.newtonking.com/json/help/index.html?topic=html/T_Newtonsoft_Json_JsonConvert.htm
string data = Newtonsoft.Json.JsonConvert.SerializeObject(dataValues, jsonSettings);
if (Log.IsVerbose3) Log.Verbose3("Writing JSON data size = {0} for grain id = Partition={1} / Row={2}",
data.Length, entity.PartitionKey, entity.RowKey);
dataSize = data.Length;
entity.StringData = data;
}
else
{
// Convert to binary format
byte[] data = SerializationManager.SerializeToByteArray(dataValues);
if (Log.IsVerbose3) Log.Verbose3("Writing binary data size = {0} for grain id = Partition={1} / Row={2}",
data.Length, entity.PartitionKey, entity.RowKey);
dataSize = data.Length;
entity.Data = data;
}
if (dataSize > MAX_DATA_SIZE)
{
var msg = string.Format("Data too large to write to Azure table. Size={0} MaxSize={1}", dataSize, MAX_DATA_SIZE);
Log.Error(0, msg);
throw new ArgumentOutOfRangeException("GrainState.Size", msg);
}
}
/// <summary> Read state data function for this storage provider. </summary>
/// <see cref="IStorageProvider#ReadStateAsync"/>
public virtual async Task ReadStateAsync(string grainType, GrainReference grainReference, GrainState grainState)
{
var keys = MakeKeys(grainType, grainReference);
if (Log.IsVerbose2)
{
Log.Verbose2("Read Keys={0}", StorageProviderUtils.PrintKeys(keys));
}
string id = HierarchicalKeyStore.MakeStoreKey(keys);
IMemoryStorageGrain storageGrain = GetStorageGrain(id);
IDictionary <string, object> state = await storageGrain.ReadStateAsync(STATE_STORE_NAME, id);
if (state != null)
{
grainState.SetAll(state);
}
}
/// <summary> Delete / Clear state data function for this storage provider. </summary>
/// <see cref="IStorageProvider#ClearStateAsync"/>
public virtual async Task ClearStateAsync(string grainType, GrainReference grainReference, GrainState grainState)
{
var keys = MakeKeys(grainType, grainReference);
string eTag = grainState.Etag; // TOD: Should this be 'null' for always Delete?
if (Log.IsVerbose2)
{
Log.Verbose2("Delete Keys={0} Etag={1}", StorageProviderUtils.PrintKeys(keys), eTag);
}
if (eTag != null && eTag != etag)
{
throw new InconsistentStateException(string.Format("Etag mismatch durign Delete: Expected = {0} Received = {1}", this.etag, eTag));
}
string key = HierarchicalKeyStore.MakeStoreKey(keys);
IMemoryStorageGrain storageGrain = GetStorageGrain(key);
await storageGrain.DeleteStateAsync(STATE_STORE_NAME, key);
etag = NewEtag();
}
public override async Task ClearStateAsync(Type grainType, GrainReference grainReference, GrainState grainState)
{
await MakeFixedLatencyCall(() => base.ClearStateAsync(grainType, grainReference, grainState));
}
/// <summary>
/// Reads persisted state from the backing store and deserializes it into the the target
/// grain state object.
/// </summary>
/// <param name="grainType">A string holding the name of the grain class.</param>
/// <param name="grainReference">Represents the long-lived identity of the grain.</param>
/// <param name="grainState">A reference to an object to hold the persisted state of the grain.</param>
/// <returns>Completion promise for this operation.</returns>
public async Task ReadStateAsync(string grainType, GrainReference grainReference, GrainState grainState)
{
if (DataManager == null) throw new ArgumentException("DataManager property not initialized");
string extendKey;
var key = this.UseGuidAsStorageKey ? grainReference.GetPrimaryKey(out extendKey).ToString() : grainReference.ToKeyString();
var entityData = await DataManager.ReadAsync(grainType, key);
if (!string.IsNullOrEmpty(entityData))
{
ConvertFromStorageFormat(grainState, entityData);
}
}
/// <summary> Read state data function for this storage provider. </summary>
/// <see cref="IStorageProvider.ReadStateAsync"/>
public async Task ReadStateAsync(string grainType, GrainReference grainReference, GrainState grainState)
{
if (tableDataManager == null) throw new ArgumentException("GrainState-Table property not initialized");
string pk = GetKeyString(grainReference);
if (Log.IsVerbose3) Log.Verbose3((int)AzureProviderErrorCode.AzureTableProvider_ReadingData, "Reading: GrainType={0} Pk={1} Grainid={2} from Table={3}", grainType, pk, grainReference, tableName);
string partitionKey = pk;
string rowKey = grainType;
GrainStateRecord record = await tableDataManager.Read(partitionKey, rowKey);
if (record != null)
{
var entity = record.Entity;
if (entity != null)
{
ConvertFromStorageFormat(grainState, entity);
grainState.Etag = record.ETag;
}
}
// Else leave grainState in previous default condition
}
/// <summary>
/// Deserialize from Azure storage format
/// </summary>
/// <param name="grainState">The grain state data to be deserialized in to</param>
/// <param name="entity">The Azure table entity the stored data</param>
internal void ConvertFromStorageFormat(GrainState grainState, GrainStateEntity entity)
{
Dictionary<string, object> dataValues = null;
try
{
if (entity.Data != null)
{
// Rehydrate
dataValues = SerializationManager.DeserializeFromByteArray<Dictionary<string, object>>(entity.Data);
}
else if (entity.StringData != null)
{
dataValues = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, object>>(entity.StringData, jsonSettings);
}
if (dataValues != null)
{
grainState.SetAll(dataValues);
}
// Else, no data found
}
catch (Exception exc)
{
var sb = new StringBuilder();
if (entity.Data != null)
{
sb.AppendFormat("Unable to convert from storage format GrainStateEntity.Data={0}", entity.Data);
}
else if (entity.StringData != null)
{
sb.AppendFormat("Unable to convert from storage format GrainStateEntity.StringData={0}", entity.StringData);
}
if (dataValues != null)
{
int i = 1;
foreach (var dvKey in dataValues.Keys)
{
object dvValue = dataValues[dvKey];
sb.AppendLine();
sb.AppendFormat("Data #{0} Key={1} Value={2} Type={3}", i, dvKey, dvValue, dvValue.GetType());
i++;
}
}
Log.Error(0, sb.ToString(), exc);
throw new AggregateException(sb.ToString(), exc);
}
}
/// <summary> Write state data function for this storage provider. </summary>
/// <see cref="IStorageProvider.WriteStateAsync"/>
public async Task WriteStateAsync(string grainType, GrainReference grainReference, GrainState grainState)
{
if (tableDataManager == null) throw new ArgumentException("GrainState-Table property not initialized");
string pk = GetKeyString(grainReference);
if (Log.IsVerbose3)
Log.Verbose3((int)AzureProviderErrorCode.AzureTableProvider_WritingData, "Writing: GrainType={0} Pk={1} Grainid={2} ETag={3} to Table={4}", grainType, pk, grainReference, grainState.Etag, tableName);
var entity = new GrainStateEntity { PartitionKey = pk, RowKey = grainType };
ConvertToStorageFormat(grainState, entity);
var record = new GrainStateRecord { Entity = entity, ETag = grainState.Etag };
try
{
await tableDataManager.Write(record);
grainState.Etag = record.ETag;
}
catch (Exception exc)
{
Log.Error((int)AzureProviderErrorCode.AzureTableProvider_WriteError, string.Format("Error Writing: GrainType={0} Grainid={1} ETag={2} to Table={3} Exception={4}",
grainType, grainReference, grainState.Etag, tableName, exc.Message), exc);
throw;
}
}
public async override Task ReadStateAsync(string grainType, GrainReference grainReference, GrainState grainState)
{
Log.Info(0, "ReadStateAsync for {0} {1} ErrorInjection={2}", grainType, grainReference, ErrorInjection);
try
{
if (ErrorInjection == ErrorInjectionPoint.BeforeRead && DoInjectErrors)
{
throw new StorageProviderInjectedError(ErrorInjection);
}
await base.ReadStateAsync(grainType, grainReference, grainState);
if (ErrorInjection == ErrorInjectionPoint.AfterRead && DoInjectErrors)
{
throw new StorageProviderInjectedError(ErrorInjection);
}
}
catch (Exception exc)
{
Log.Warn(0, "Injected error during ReadStateAsync for {0} {1} Exception = {2}", grainType, grainReference, exc);
throw;
}
}
/// <summary>
/// Writes a file representing a grain state object.
/// </summary>
/// <param name="collectionName">The type of the grain state object.</param>
/// <param name="key">The grain id string.</param>
/// <param name="entityData">The grain state data to be stored./</param>
/// <returns>Completion promise for this operation.</returns>
public async Task WriteAsync(string collectionName, string key, GrainState entityData)
{
var collection = await GetCollection(collectionName);
var query = BsonDocument.Parse("{__key:\"" + key + "\"}");
using (var cursor = await collection.FindAsync(query))
{
var existing = (await cursor.ToListAsync()).FirstOrDefault();
var json = JsonConvert.SerializeObject(entityData, JsonSetting);
var doc = BsonSerializer.Deserialize<BsonDocument>(json);
doc["__key"] = key;
if (existing != null)
{
doc["_id"] = existing["_id"];
await collection.ReplaceOneAsync(query, doc);
}
else
{
await collection.InsertOneAsync(doc);
}
}
}
/// <summary>
/// Constructs a grain state instance by deserializing a JSON document.
/// </summary>
/// <param name="grainState">Grain state to be populated for storage.</param>
/// <param name="entityData">JSON storage format representaiton of the grain state.</param>
protected static void ConvertFromStorageFormat(GrainState grainState, string entityData)
{
object data = JsonConvert.DeserializeObject(entityData, grainState.GetType(), GrainStateMongoDataManager.JsonSetting);
var dict = ((GrainState)data).AsDictionary();
grainState.SetAll(dict);
}
/// <summary>
/// Removes grain state from its backing store, if found.
/// </summary>
/// <param name="grainType">A string holding the name of the grain class.</param>
/// <param name="grainReference">Represents the long-lived identity of the grain.</param>
/// <param name="grainState">An object holding the persisted state of the grain.</param>
/// <returns></returns>
public Task ClearStateAsync(string grainType, GrainReference grainReference, GrainState grainState)
{
if (DataManager == null) throw new ArgumentException("DataManager property not initialized");
string extendKey;
var key = this.UseGuidAsStorageKey ? grainReference.GetPrimaryKey(out extendKey).ToString() : grainReference.ToKeyString();
return DataManager.DeleteAsync(grainType, key);
}
internal async Task Relational_Xml_WriteReadStreaming(string grainType, GrainReference grainReference, GrainState <TestStateGeneric1 <string> > grainState)
{
((AdoNetStorageProvider)PersistenceStorageTests.Storage).StorageSerializationPicker = XmlStreamingPicker;
await PersistenceStorageTests.Store_WriteRead(grainType, grainReference, grainState);
}
/// <summary> Write state data function for this storage provider. </summary>
/// <see cref="IStorageProvider.WriteStateAsync"/>
public async Task WriteStateAsync(string grainType, GrainReference grainReference, GrainState grainState)
{
if (tableDataManager == null)
{
throw new ArgumentException("GrainState-Table property not initialized");
}
string pk = GetKeyString(grainReference);
if (Log.IsVerbose3)
{
Log.Verbose3((int)AzureProviderErrorCode.AzureTableProvider_WritingData, "Writing: GrainType={0} Pk={1} Grainid={2} ETag={3} to Table={4}", grainType, pk, grainReference, grainState.Etag, tableName);
}
var entity = new GrainStateEntity {
PartitionKey = pk, RowKey = grainType
};
ConvertToStorageFormat(grainState, entity);
var record = new GrainStateRecord {
Entity = entity, ETag = grainState.Etag
};
try
{
await tableDataManager.Write(record);
grainState.Etag = record.ETag;
}
catch (Exception exc)
{
Log.Error((int)AzureProviderErrorCode.AzureTableProvider_WriteError, string.Format("Error Writing: GrainType={0} Grainid={1} ETag={2} to Table={3} Exception={4}",
grainType, grainReference, grainState.Etag, tableName, exc.Message), exc);
throw;
}
}
internal async Task Relational_ChangeStorageFormatFromBinaryToJsonInMemory_WriteRead(string grainType, GrainReference grainReference, GrainState <TestState1> grainState)
{
//Use the default binary serializer and deserializer. Now the data in the storage is in binary format.
var initialVersion = grainState.ETag;
await PersistenceStorageTests.Store_WriteRead(grainType, grainReference, grainState);
var firstVersion = grainState.ETag;
Assert.NotEqual(initialVersion, firstVersion);
//Change the serializer and deserializer to a JSON one. The real world situation might be more complicated that the data
//might not be in memory upon first read but the previous serializer format would need to used to retrieve data and the
//new one to write and after that the new one used to both read and write data.
//Change both the serializer and deserializer and do writing and reading once more just to be sure.
((AdoNetStorageProvider)PersistenceStorageTests.Storage).StorageSerializationPicker = JsonPicker;
await PersistenceStorageTests.Store_WriteRead(grainType, grainReference, grainState);
var secondVersion = grainState.ETag;
Assert.NotEqual(firstVersion, secondVersion);
}
/// <summary> Read state data function for this storage provider. </summary>
/// <see cref="IStorageProvider#ReadStateAsync"/>
public async Task ReadStateAsync(string grainType, GrainReference grainReference, GrainState grainState)
{
var primaryKey = grainReference.ToKeyString();
if (Log.IsVerbose3)
{
Log.Verbose3((int)SimpleSQLServerProviderErrorCodes.SimpleSQLServerProvide_ReadingData,
"Reading: GrainType={0} Pk={1} Grainid={2} from DataSource={3}",
grainType, primaryKey, grainReference, this.sqlconnBuilder.DataSource + "." + this.sqlconnBuilder.InitialCatalog);
}
var data = new Dictionary <string, object>();
using (var db = new KeyValueDbContext(this.sqlconnBuilder.ConnectionString))
{
switch (this.useJsonOrBinaryFormat)
{
case StorageFormatEnum.Binary:
case StorageFormatEnum.Both:
{
var value = await db.KeyValues.Where(s => s.GrainKeyId.Equals(primaryKey)).Select(s => s.BinaryContent).SingleOrDefaultAsync();
if (value != null)
{
data = SerializationManager.DeserializeFromByteArray <Dictionary <string, object> >(value);
}
}
break;
case StorageFormatEnum.Json:
{
var value = await db.KeyValues.Where(s => s.GrainKeyId.Equals(primaryKey)).Select(s => s.JsonContext).SingleOrDefaultAsync();
if (!string.IsNullOrEmpty(value))
{
data = JsonConvert.DeserializeObject <Dictionary <string, object> >(value, jsonSettings);
}
}
break;
default:
break;
}
}
grainState.SetAll(data);
grainState.Etag = Guid.NewGuid().ToString();
}
/// <summary> Deleet / Clear state data function for this storage provider. </summary>
/// <see cref="IStorageProvider#ClearStateAsync"/>
public Task ClearStateAsync(string grainType, GrainReference grainReference, GrainState grainState)
{
int num = FindStorageShard(grainType, grainReference);
IStorageProvider provider = storageProviders[num];
return provider.ClearStateAsync(grainType, grainReference, grainState);
}
/// <summary> Clear state data function for this storage provider. </summary>
/// <remarks>
/// </remarks>
/// <see cref="IStorageProvider#ClearStateAsync"/>
public async Task ClearStateAsync(string grainType, GrainReference grainReference, GrainState grainState)
{
var primaryKey = grainReference.ToKeyString();
if (Log.IsVerbose3)
{
Log.Verbose3((int)SimpleSQLServerProviderErrorCodes.SimpleSQLServerStorageProvider_ClearingData,
"Clearing: GrainType={0} Pk={1} Grainid={2} ETag={3} DeleteStateOnClear={4} from DataSource={5}",
grainType, primaryKey, grainReference, grainState.Etag, this.sqlconnBuilder.DataSource + "." + this.sqlconnBuilder.InitialCatalog);
}
var entity = new KeyValueStore()
{
GrainKeyId = primaryKey
};
using (var db = new KeyValueDbContext(this.sqlconnBuilder.ConnectionString))
{
db.KeyValues.Attach(entity);
db.KeyValues.Remove(entity);
await db.SaveChangesAsync();
}
}
/// <summary> Clear / Delete state data function for this storage provider. </summary>
/// <remarks>
/// If the <c>DeleteStateOnClear</c> is set to <c>true</c> then the table row
/// for this grain will be deleted / removed, otherwise the table row will be
/// cleared by overwriting with default / null values.
/// </remarks>
/// <see cref="IStorageProvider.ClearStateAsync"/>
public async Task ClearStateAsync(string grainType, GrainReference grainReference, GrainState grainState)
{
if (tableDataManager == null)
{
throw new ArgumentException("GrainState-Table property not initialized");
}
string pk = GetKeyString(grainReference);
if (Log.IsVerbose3)
{
Log.Verbose3((int)AzureProviderErrorCode.AzureTableProvider_WritingData, "Clearing: GrainType={0} Pk={1} Grainid={2} ETag={3} DeleteStateOnClear={4} from Table={5}", grainType, pk, grainReference, grainState.Etag, isDeleteStateOnClear, tableName);
}
var entity = new GrainStateEntity {
PartitionKey = pk, RowKey = grainType
};
var record = new GrainStateRecord {
Entity = entity, ETag = grainState.Etag
};
string operation = "Clearing";
try
{
if (isDeleteStateOnClear)
{
operation = "Deleting";
await tableDataManager.Delete(record);
}
else
{
await tableDataManager.Write(record);
}
grainState.Etag = record.ETag; // Update in-memory data to the new ETag
}
catch (Exception exc)
{
Log.Error((int)AzureProviderErrorCode.AzureTableProvider_DeleteError, string.Format("Error {0}: GrainType={1} Grainid={2} ETag={3} from Table={4} Exception={5}",
operation, grainType, grainReference, grainState.Etag, tableName, exc.Message), exc);
throw;
}
}
/// <summary> Write state data function for this storage provider. </summary>
/// <see cref="IStorageProvider#WriteStateAsync"/>
public Task WriteStateAsync(Type grainType, GrainReference grainReference, GrainState grainState)
{
int num = FindStorageShard(grainType.FullName, grainReference);
IStorageProvider provider = storageProviders[num];
return provider.WriteStateAsync(grainType, grainReference, grainState);
}
/// <summary> Write state data function for this storage provider. </summary>
/// <see cref="IStorageProvider#WriteStateAsync"/>
public async Task WriteStateAsync(string grainType, GrainReference grainReference, GrainState grainState)
{
var primaryKey = grainReference.ToKeyString();
if (Log.IsVerbose3)
{
Log.Verbose3((int)SimpleSQLServerProviderErrorCodes.SimpleSQLServerProvide_WritingData,
"Writing: GrainType={0} PrimaryKey={1} Grainid={2} ETag={3} to DataSource={4}",
grainType, primaryKey, grainReference, grainState.Etag, this.sqlconnBuilder.DataSource + "." + this.sqlconnBuilder.InitialCatalog);
}
var data = grainState.AsDictionary();
byte[] payload = null;
string jsonpayload = string.Empty;
if (this.useJsonOrBinaryFormat != StorageFormatEnum.Json)
{
payload = SerializationManager.SerializeToByteArray(data);
}
if (this.useJsonOrBinaryFormat == StorageFormatEnum.Json || this.useJsonOrBinaryFormat == StorageFormatEnum.Both)
{
jsonpayload = JsonConvert.SerializeObject(data, jsonSettings);
}
//await redisDatabase.StringSetAsync(primaryKey, json);
var kvb = new KeyValueStore()
{
JsonContext = jsonpayload,
BinaryContent = payload,
GrainKeyId = primaryKey,
};
using (var db = new KeyValueDbContext(this.sqlconnBuilder.ConnectionString))
{
db.Set <KeyValueStore>().AddOrUpdate(kvb);
await db.SaveChangesAsync();
}
}
public async Task ReadStateAsync( string grainType, GrainReference grainId, GrainState grainState )
{
try
{
var blobName = GetBlobName( grainType, grainId );
var blob = container.GetBlockBlobReference( blobName );
var exists = await blob.ExistsAsync();
if( !exists )
{
return;
}
var text = await blob.DownloadTextAsync();
if( string.IsNullOrWhiteSpace( text ) )
{
return;
}
var data = JsonConvert.DeserializeObject( text, grainState.GetType(), settings );
var dict = ( ( GrainState )data ).AsDictionary();
grainState.SetAll( dict );
grainState.Etag = blob.Properties.ETag;
}
catch( Exception ex )
{
Log.Error( 0, ex.ToString() );
}
}
public async Task ClearStateAsync(string grainType, GrainReference grainReference, GrainState grainState)
{
var stateName = grainState.GetType().Name;
var key = grainReference.ToKeyString();
var id = string.Format(CultureInfo.InvariantCulture, "{0}/{1}", stateName, key);
using (IAsyncDocumentSession session = this.documentStore.OpenAsyncSession())
{
session.Advanced.Defer(new DeleteCommandData
{
Key = id
});
await session.SaveChangesAsync();
}
}
public async Task WriteStateAsync( string grainType, GrainReference grainId, GrainState grainState )
{
try
{
var blobName = GetBlobName( grainType, grainId );
var grainStateDictionary = grainState.AsDictionary();
var storedData = JsonConvert.SerializeObject( grainStateDictionary, settings );
Log.Verbose( "Serialized grain state is: {0}.", storedData );
var blob = container.GetBlockBlobReference( blobName );
blob.Properties.ContentType = "application/json";
await
blob.UploadTextAsync(
storedData,
Encoding.UTF8,
AccessCondition.GenerateIfMatchCondition( grainState.Etag ),
null,
null );
grainState.Etag = blob.Properties.ETag;
}
catch( Exception ex )
{
Log.Error( 0, ex.ToString() );
}
}
/// <summary> Write state data function for this storage provider. </summary>
/// <see cref="IStorageProvider#WriteStateAsync"/>
public virtual async Task WriteStateAsync(string grainType, GrainReference grainReference, GrainState grainState)
{
var keys = MakeKeys(grainType, grainReference);
var data = grainState.AsDictionary();
string receivedEtag = grainState.Etag;
if (Log.IsVerbose2)
{
Log.Verbose2("Write {0} ", StorageProviderUtils.PrintOneWrite(keys, data, receivedEtag));
}
if (receivedEtag != null && receivedEtag != etag)
{
throw new InconsistentStateException(string.Format("Etag mismatch durign Write: Expected = {0} Received = {1}", etag, receivedEtag));
}
string key = HierarchicalKeyStore.MakeStoreKey(keys);
IMemoryStorageGrain storageGrain = GetStorageGrain(key);
await storageGrain.WriteStateAsync(STATE_STORE_NAME, key, data);
etag = NewEtag();
}
public async Task ClearStateAsync( string grainType, GrainReference grainId, GrainState grainState )
{
try
{
var blobName = GetBlobName( grainType, grainId );
var blob = container.GetBlockBlobReference( blobName );
await
blob.DeleteIfExistsAsync(
DeleteSnapshotsOption.None,
AccessCondition.GenerateIfMatchCondition( grainState.Etag ),
null,
null );
grainState.Etag = blob.Properties.ETag;
}
catch( Exception ex )
{
Log.Error( 0, ex.ToString() );
}
}
/// <summary>
/// Writes to storage, reads back and asserts both the version and the state.
/// </summary>
/// <typeparam name="T">The grain state type.</typeparam>
/// <param name="grainTypeName">The type of the grain.</param>
/// <param name="grainReference">The grain reference as would be given by Orleans.</param>
/// <param name="grainState">The grain state the grain would hold and Orleans pass.</param>
/// <returns></returns>
internal async Task Store_WriteRead <T>(string grainTypeName, GrainReference grainReference, GrainState <T> grainState) where T : new()
{
await Storage.WriteStateAsync(grainTypeName, grainReference, grainState);
var storedGrainState = new GrainState <T> {
State = new T()
};
await Storage.ReadStateAsync(grainTypeName, grainReference, storedGrainState);
Assert.Equal(grainState.ETag, storedGrainState.ETag);
Assert.Equal(grainState.State, storedGrainState.State);
}
public Task ClearStateAsync(string grainType, GrainReference grainReference, GrainState grainState)
{
var entity = new DynamicTableEntity(grainReference.ToKeyString(), grainType) { ETag = "*" };
return _table.ExecuteAsync(TableOperation.Delete(entity));
}
/// <summary> Read state data function for this storage provider. </summary>
/// <see cref="IStorageProvider.ReadStateAsync"/>
public async Task ReadStateAsync(string grainType, GrainReference grainReference, GrainState grainState)
{
if (tableDataManager == null)
{
throw new ArgumentException("GrainState-Table property not initialized");
}
string pk = GetKeyString(grainReference);
if (Log.IsVerbose3)
{
Log.Verbose3((int)AzureProviderErrorCode.AzureTableProvider_ReadingData, "Reading: GrainType={0} Pk={1} Grainid={2} from Table={3}", grainType, pk, grainReference, tableName);
}
string partitionKey = pk;
string rowKey = grainType;
GrainStateRecord record = await tableDataManager.Read(partitionKey, rowKey);
if (record != null)
{
var entity = record.Entity;
if (entity != null)
{
ConvertFromStorageFormat(grainState, entity);
grainState.Etag = record.ETag;
}
}
// Else leave grainState in previous default condition
}
/// <summary> Clear / Delete state data function for this storage provider. </summary>
/// <remarks>
/// If the <c>DeleteStateOnClear</c> is set to <c>true</c> then the table row
/// for this grain will be deleted / removed, otherwise the table row will be
/// cleared by overwriting with default / null values.
/// </remarks>
/// <see cref="IStorageProvider.ClearStateAsync"/>
public async Task ClearStateAsync(string grainType, GrainReference grainReference, GrainState grainState)
{
if (tableDataManager == null) throw new ArgumentException("GrainState-Table property not initialized");
string pk = GetKeyString(grainReference);
if (Log.IsVerbose3) Log.Verbose3((int)AzureProviderErrorCode.AzureTableProvider_WritingData, "Clearing: GrainType={0} Pk={1} Grainid={2} ETag={3} DeleteStateOnClear={4} from Table={5}", grainType, pk, grainReference, grainState.Etag, isDeleteStateOnClear, tableName);
var entity = new GrainStateEntity { PartitionKey = pk, RowKey = grainType };
var record = new GrainStateRecord { Entity = entity, ETag = grainState.Etag };
string operation = "Clearing";
try
{
if (isDeleteStateOnClear)
{
operation = "Deleting";
await tableDataManager.Delete(record);
}
else
{
await tableDataManager.Write(record);
}
grainState.Etag = record.ETag; // Update in-memory data to the new ETag
}
catch (Exception exc)
{
Log.Error((int)AzureProviderErrorCode.AzureTableProvider_DeleteError, string.Format("Error {0}: GrainType={1} Grainid={2} ETag={3} from Table={4} Exception={5}",
operation, grainType, grainReference, grainState.Etag, tableName, exc.Message), exc);
throw;
}
}
