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; } }