/// <summary> Initialization function for this storage provider. </summary> public async Task Init(CancellationToken ct) { var stopWatch = Stopwatch.StartNew(); try { var initMsg = string.Format("Init: Name={0} ServiceId={1} Table={2} DeleteStateOnClear={3}", this.name, this.options.ServiceId, this.options.TableName, this.options.DeleteStateOnClear); this.jsonSettings = OrleansJsonSerializer.UpdateSerializerSettings( OrleansJsonSerializer.GetDefaultSerializerSettings(this.typeResolver, this.grainFactory), this.options.UseFullAssemblyNames, this.options.IndentJson, this.options.TypeNameHandling); this.options.ConfigureJsonSerializerSettings?.Invoke(this.jsonSettings); this.logger.LogInformation((int)ErrorCode.StorageProviderBase, $"AWS DynamoDB Grain Storage {this.name} is initializing: {initMsg}"); this.storage = new DynamoDBStorage(this.logger, this.options.Service, this.options.AccessKey, this.options.SecretKey, this.options.ReadCapacityUnits, this.options.WriteCapacityUnits, this.options.UseProvisionedThroughput); await storage.InitializeTable(this.options.TableName, new List <KeySchemaElement> { new KeySchemaElement { AttributeName = GRAIN_REFERENCE_PROPERTY_NAME, KeyType = KeyType.HASH }, new KeySchemaElement { AttributeName = GRAIN_TYPE_PROPERTY_NAME, KeyType = KeyType.RANGE } }, new List <AttributeDefinition> { new AttributeDefinition { AttributeName = GRAIN_REFERENCE_PROPERTY_NAME, AttributeType = ScalarAttributeType.S }, new AttributeDefinition { AttributeName = GRAIN_TYPE_PROPERTY_NAME, AttributeType = ScalarAttributeType.S } }, secondaryIndexes : null, ttlAttributeName : this.options.TimeToLive.HasValue?GRAIN_TTL_PROPERTY_NAME : null); stopWatch.Stop(); this.logger.LogInformation((int)ErrorCode.StorageProviderBase, $"Initializing provider {this.name} of type {this.GetType().Name} in stage {this.options.InitStage} took {stopWatch.ElapsedMilliseconds} Milliseconds."); } catch (Exception exc) { stopWatch.Stop(); this.logger.LogError((int)ErrorCode.Provider_ErrorFromInit, $"Initialization failed for provider {this.name} of type {this.GetType().Name} in stage {this.options.InitStage} in {stopWatch.ElapsedMilliseconds} Milliseconds.", exc); throw; } }
/// <summary> Initialization function for this storage provider. </summary> /// <see cref="IProvider.Init"/> public Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config) { Name = name; serviceId = providerRuntime.ServiceId.ToString(); if (config.Properties.ContainsKey(TABLE_NAME_PROPERTY_NAME)) { tableName = config.Properties[TABLE_NAME_PROPERTY_NAME]; } isDeleteStateOnClear = config.Properties.ContainsKey(DELETE_ON_CLEAR_PROPERTY_NAME) && "true".Equals(config.Properties[DELETE_ON_CLEAR_PROPERTY_NAME], StringComparison.OrdinalIgnoreCase); Log = providerRuntime.GetLogger("Storage.AWSDynamoDBStorage." + id); var initMsg = string.Format("Init: Name={0} ServiceId={1} Table={2} DeleteStateOnClear={3}", Name, serviceId, tableName, isDeleteStateOnClear); if (config.Properties.ContainsKey(USE_JSON_FORMAT_PROPERTY_NAME)) { useJsonFormat = "true".Equals(config.Properties[USE_JSON_FORMAT_PROPERTY_NAME], StringComparison.OrdinalIgnoreCase); } var grainFactory = providerRuntime.ServiceProvider.GetRequiredService <IGrainFactory>(); this.jsonSettings = OrleansJsonSerializer.UpdateSerializerSettings(OrleansJsonSerializer.GetDefaultSerializerSettings(grainFactory), config); initMsg = string.Format("{0} UseJsonFormat={1}", initMsg, useJsonFormat); Log.Info(ErrorCode.StorageProviderBase, "AWS DynamoDB Provider: {0}", initMsg); storage = new DynamoDBStorage(config.Properties[DATA_CONNECTION_STRING_PROPERTY_NAME], Log); return(storage.InitializeTable(tableName, new List <KeySchemaElement> { new KeySchemaElement { AttributeName = GRAIN_REFERENCE_PROPERTY_NAME, KeyType = KeyType.HASH }, new KeySchemaElement { AttributeName = GRAIN_TYPE_PROPERTY_NAME, KeyType = KeyType.RANGE } }, new List <AttributeDefinition> { new AttributeDefinition { AttributeName = GRAIN_REFERENCE_PROPERTY_NAME, AttributeType = ScalarAttributeType.S }, new AttributeDefinition { AttributeName = GRAIN_TYPE_PROPERTY_NAME, AttributeType = ScalarAttributeType.S } })); }
private Task Init(CancellationToken ct) { _jsonSettings = OrleansJsonSerializer.UpdateSerializerSettings(OrleansJsonSerializer.GetDefaultSerializerSettings(_typeResolver, _grainFactory), false, false, null); var directory = new DirectoryInfo(_options.RootDirectory); if (!directory.Exists) { directory.Create(); } return(Task.CompletedTask); }
private Task Init(CancellationToken ct) { try { _jsonSettings = OrleansJsonSerializer .UpdateSerializerSettings(OrleansJsonSerializer.GetDefaultSerializerSettings(_typeResolver, _grainFactory), _options.UseFullAssemblyNames, _options.IndentJson, _options.TypeNameHandling); _dataManager = new GrainStateDataManager(_options); } catch (Exception ex) { throw ex; } return(Task.CompletedTask); }
public MessageSerializer(IServiceProvider services) { serializer = new Lazy <OrleansJsonSerializer>(() => { var system = services.GetRequiredService <IActorSystem>(); var sr = new OrleansJsonSerializer(services); var settings = (Lazy <JsonSerializerSettings>)sr.GetType().GetField("settings", BindingFlags.Instance | BindingFlags.NonPublic) !.GetValue(sr); settings !.Value.Converters.Add(new ObserverRefConverter(system)); settings !.Value.Converters.Add(new ClientRefConverter(system)); settings !.Value.Converters.Add(new ActorRefConverter(system)); settings !.Value.Converters.Add(new TypedActorRefConverter(system)); settings !.Value.Converters.Add(new StreamRefConverter(services)); settings !.Value.Converters.Add(new StreamFilterConverter()); return(sr); }); }
public JsonGrainStateSerializer(ITypeResolver typeResolver, IGrainFactory grainFactory, MongoDBGrainStorageOptions options) { var jsonSettings = OrleansJsonSerializer.GetDefaultSerializerSettings(typeResolver, grainFactory); options?.ConfigureJsonSerializerSettings?.Invoke(jsonSettings); this.serializer = JsonSerializer.Create(jsonSettings); if (options?.ConfigureJsonSerializerSettings == null) { //// https://github.com/OrleansContrib/Orleans.Providers.MongoDB/issues/44 //// Always include the default value, so that the deserialization process can overwrite default //// values that are not equal to the system defaults. this.serializer.NullValueHandling = NullValueHandling.Include; this.serializer.DefaultValueHandling = DefaultValueHandling.Populate; } }
private T NewtonsoftJsonSerializeRoundtrip <T>(T obj) { var settings = OrleansJsonSerializer.GetDefaultSerializerSettings(this.HostedCluster.SerializationManager, this.GrainFactory); // http://james.newtonking.com/json/help/index.html?topic=html/T_Newtonsoft_Json_JsonConvert.htm string json = Newtonsoft.Json.JsonConvert.SerializeObject(obj, settings); object other = Newtonsoft.Json.JsonConvert.DeserializeObject(json, obj.GetType(), settings); #if NETSTANDARD_TODO // On .NET Standard, currently we need to manually fixup grain references. var otherAsRef = other as Orleans.Runtime.GrainReference; if (otherAsRef != null) { this.GrainFactory.BindGrainReference(otherAsRef); } #endif return((T)other); }
private async Task Init(CancellationToken cancellationToken) { try { _jsonSettings = OrleansJsonSerializer.GetDefaultSerializerSettings(_typeResolver, _grainFactory); _jsonSettings.TypeNameHandling = _cassandraStorageOptions.JsonSerialization.TypeNameHandling; _jsonSettings.MetadataPropertyHandling = _cassandraStorageOptions.JsonSerialization.MetadataPropertyHandling; if (_cassandraStorageOptions.JsonSerialization.UseFullAssemblyNames) { _jsonSettings.TypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Full; } if (_cassandraStorageOptions.JsonSerialization.IndentJson) { _jsonSettings.Formatting = Formatting.Indented; } var cassandraOptions = _cassandraStorageOptions; var cassandraCluster = Cluster.Builder() .AddContactPoints(cassandraOptions.ContactPoints.Split(',')) .WithDefaultKeyspace(cassandraOptions.Keyspace) .Build(); var session = cassandraCluster.ConnectAndCreateDefaultKeyspaceIfNotExists( new Dictionary <string, string> { { "class", "SimpleStrategy" }, { "replication_factor", cassandraOptions.ReplicationFactor.ToString() } }); var mappingConfiguration = new MappingConfiguration().Define(new EntityMappings(cassandraOptions.TableName)); _dataTable = new Table <CassandraGrainState>(session, mappingConfiguration); await Task.Run(() => _dataTable.CreateIfNotExists(), cancellationToken).ConfigureAwait(false); _mapper = new Mapper(session, mappingConfiguration); } catch (DriverException) { _logger.LogWarning("Cassandra driver error occured while initializing grain storage for service {serviceId}.", _serviceId); throw; } }
public FileDatabaseInterface( IGrainFactory grainFactory, ILogger <FileDatabaseInterface> logger, ITypeResolver typeResolver, FileDatabaseInterfaceOptions options) { _grainFactory = grainFactory; _logger = logger; _typeResolver = typeResolver; _serializerSettings = OrleansJsonSerializer.GetDefaultSerializerSettings(_typeResolver, _grainFactory); var dataDirectory = options.DataDirectory; if (string.IsNullOrWhiteSpace(dataDirectory)) { throw new ArgumentException("Data directory not specified"); } var directory = new DirectoryInfo(dataDirectory); if (!directory.Exists) { directory.Create(); } _dataDirectory = directory.FullName; _logger.LogInformation("Data directory: {0}", _dataDirectory); _databaseScript = options.DatabaseScript; var file = new FileInfo(_databaseScript); if (!file.Exists) { throw new FileNotFoundException("Database script not found"); } _logger.LogInformation("Database script: {0}", _databaseScript); _componentName = options.ComponentName; _logger.LogInformation("Component name: {0}", _componentName); var info = this.CreateProcessInfo(); _process = Process.Start(info); }
/// <summary> Initialization function for this storage provider. </summary> /// <see cref="IProvider.Init"/> public Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config) { Name = name; serviceId = providerRuntime.ServiceId.ToString(); this.serializationManager = providerRuntime.ServiceProvider.GetRequiredService <SerializationManager>(); if (!config.Properties.ContainsKey(DataConnectionStringPropertyName) || string.IsNullOrWhiteSpace(config.Properties[DataConnectionStringPropertyName])) { throw new ArgumentException("DataConnectionString property not set"); } dataConnectionString = config.Properties["DataConnectionString"]; if (config.Properties.ContainsKey(TableNamePropertyName)) { tableName = config.Properties[TableNamePropertyName]; } isDeleteStateOnClear = config.Properties.ContainsKey(DeleteOnClearPropertyName) && "true".Equals(config.Properties[DeleteOnClearPropertyName], StringComparison.OrdinalIgnoreCase); var loggerFactory = providerRuntime.ServiceProvider.GetRequiredService <ILoggerFactory>(); var loggerName = $"{this.GetType().FullName}.{Name}"; logger = loggerFactory.CreateLogger(loggerName); Log = new LoggerWrapper(logger, loggerName, loggerFactory); var initMsg = string.Format("Init: Name={0} ServiceId={1} Table={2} DeleteStateOnClear={3}", Name, serviceId, tableName, isDeleteStateOnClear); if (config.Properties.ContainsKey(UseJsonFormatPropertyName)) { useJsonFormat = "true".Equals(config.Properties[UseJsonFormatPropertyName], StringComparison.OrdinalIgnoreCase); } var grainFactory = providerRuntime.ServiceProvider.GetRequiredService <IGrainFactory>(); this.jsonSettings = OrleansJsonSerializer.UpdateSerializerSettings(OrleansJsonSerializer.GetDefaultSerializerSettings(this.serializationManager, grainFactory), config); initMsg = String.Format("{0} UseJsonFormat={1}", initMsg, useJsonFormat); this.logger.Info((int)AzureProviderErrorCode.AzureTableProvider_InitProvider, initMsg); logger.Info((int)AzureProviderErrorCode.AzureTableProvider_ParamConnectionString, "AzureTableStorage Provider is using DataConnectionString: {0}", ConfigUtilities.RedactConnectionStringInfo(dataConnectionString)); tableDataManager = new GrainStateTableDataManager(tableName, dataConnectionString, loggerFactory); return(tableDataManager.InitTableAsync()); }
public async Task GrainReference_Json_Serialization_Nested() { var settings = OrleansJsonSerializer.GetDefaultSerializerSettings(HostedCluster.SerializationManager, HostedCluster.GrainFactory); var grain = HostedCluster.GrainFactory.GetGrain <ISimpleGrain>(GetRandomGrainId()); await grain.SetA(56820); var input = new GenericGrainReferenceHolder { Reference = grain as GrainReference }; var json = JsonConvert.SerializeObject(input, settings); var output = JsonConvert.DeserializeObject <GenericGrainReferenceHolder>(json, settings); Assert.Equal(input.Reference, output.Reference); var reference = output.Reference; Assert.Equal(56820, await((ISimpleGrain)reference).GetA()); }
/// <summary> Initialization function for this storage provider. </summary> private async Task Init(CancellationToken ct) { var stopWatch = Stopwatch.StartNew(); try { this.logger.LogInformation((int)MorsteadEtcdProviderErrorCode.MorsteadEtcdProvider_InitProvider, $"MoresteadEtcdGrainStorage initializing: {this.options.ToString()}"); this.logger.LogInformation((int)MorsteadEtcdProviderErrorCode.MorsteadEtcdProvider_ParamConnectionString, "MoresteadEtcdGrainStorage is using storage key prefix {0}", name); this.jsonSettings = OrleansJsonSerializer.UpdateSerializerSettings(OrleansJsonSerializer.GetDefaultSerializerSettings(this.typeResolver, this.grainFactory), this.options.UseFullAssemblyNames, this.options.IndentJson, this.options.TypeNameHandling); this.options.ConfigureJsonSerializerSettings?.Invoke(this.jsonSettings); etcdClient = new EtcdClient(this.options.ConnectionString); stopWatch.Stop(); this.logger.LogInformation((int)MorsteadEtcdProviderErrorCode.MorsteadEtcdProvider_InitProvider, $"Initializing provider {this.name} of type {this.GetType().Name} in stage {this.options.InitStage} took {stopWatch.ElapsedMilliseconds} Milliseconds."); } catch (Exception ex) { stopWatch.Stop(); this.logger.LogError((int)ErrorCode.Provider_ErrorFromInit, $"Initialization failed for provider {this.name} of type {this.GetType().Name} in stage {this.options.InitStage} in {stopWatch.ElapsedMilliseconds} Milliseconds.", ex); throw; } }
private async Task Init(CancellationToken ct) { var stopWatch = Stopwatch.StartNew(); try { this.logger.LogInformation((int)AzureProviderErrorCode.AzureTableProvider_InitProvider, $"AzureTableGrainStorage {name} initializing: {this.options.ToString()}"); this.logger.LogInformation((int)AzureProviderErrorCode.AzureTableProvider_ParamConnectionString, $"AzureTableGrainStorage {name} is using DataConnectionString: {ConfigUtilities.RedactConnectionStringInfo(this.options.ConnectionString)}"); this.JsonSettings = OrleansJsonSerializer.UpdateSerializerSettings(OrleansJsonSerializer.GetDefaultSerializerSettings(this.typeResolver, this.grainFactory), this.options.UseFullAssemblyNames, this.options.IndentJson, this.options.TypeNameHandling); this.tableDataManager = new GrainStateTableDataManager(this.options.TableName, this.options.ConnectionString, this.loggerFactory); await this.tableDataManager.InitTableAsync(); stopWatch.Stop(); this.logger.LogInformation((int)AzureProviderErrorCode.AzureTableProvider_InitProvider, $"Initializing provider {this.name} of type {this.GetType().Name} in stage {this.options.InitStage} took {stopWatch.ElapsedMilliseconds} Milliseconds."); } catch (Exception ex) { stopWatch.Stop(); this.logger.LogError((int)ErrorCode.Provider_ErrorFromInit, $"Initialization failed for provider {this.name} of type {this.GetType().Name} in stage {this.options.InitStage} in {stopWatch.ElapsedMilliseconds} Milliseconds.", ex); throw; } }
/// <summary> Initialization function for this storage provider. </summary> private async Task Init(CancellationToken ct) { var stopWatch = Stopwatch.StartNew(); if (db != null) { return; } try { this.logger.LogInformation((int)MorsteadProviderErrorCode.MorsteadProvider_InitProvider, $"MoresteadGrainStorage initializing: {this.options.ToString()}"); this.logger.LogInformation((int)MorsteadProviderErrorCode.MorsteadProvider_ParamConnectionString, "MoresteadGrainStorage is using Container Name {0}", this.options.ContainerName); this.jsonSettings = OrleansJsonSerializer.UpdateSerializerSettings(OrleansJsonSerializer.GetDefaultSerializerSettings(this.typeResolver, this.grainFactory), this.options.UseFullAssemblyNames, this.options.IndentJson, this.options.TypeNameHandling); this.options.ConfigureJsonSerializerSettings?.Invoke(this.jsonSettings); if (!dbs.ContainsKey(this.name)) { db = new LiteDatabase(this.name); await Task.Run(() => grains = db.GetCollection <MorsteadGrainStorageModel>("grains")); grains.EnsureIndex(x => x.ETag); dbs.Add(name, db); } else { db = dbs[this.name]; await Task.Run(() => grains = db.GetCollection <MorsteadGrainStorageModel>("grains")); } stopWatch.Stop(); this.logger.LogInformation((int)MorsteadProviderErrorCode.MorsteadProvider_InitProvider, $"Initializing provider {this.name} of type {this.GetType().Name} in stage {this.options.InitStage} took {stopWatch.ElapsedMilliseconds} Milliseconds."); } catch (Exception ex) { stopWatch.Stop(); this.logger.LogError((int)ErrorCode.Provider_ErrorFromInit, $"Initialization failed for provider {this.name} of type {this.GetType().Name} in stage {this.options.InitStage} in {stopWatch.ElapsedMilliseconds} Milliseconds.", ex); throw; } }
/// <summary> Initialization function for this storage provider. </summary> /// <see cref="IProvider.Init"/> public Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config) { Name = name; serviceId = providerRuntime.ServiceId.ToString(); if (!config.Properties.ContainsKey(DataConnectionStringPropertyName) || string.IsNullOrWhiteSpace(config.Properties[DataConnectionStringPropertyName])) { throw new ArgumentException("DataConnectionString property not set"); } dataConnectionString = config.Properties["DataConnectionString"]; if (config.Properties.ContainsKey(TableNamePropertyName)) { tableName = config.Properties[TableNamePropertyName]; } isDeleteStateOnClear = config.Properties.ContainsKey(DeleteOnClearPropertyName) && "true".Equals(config.Properties[DeleteOnClearPropertyName], StringComparison.OrdinalIgnoreCase); Log = providerRuntime.GetLogger("Storage.AzureTableStorage." + id); var initMsg = string.Format("Init: Name={0} ServiceId={1} Table={2} DeleteStateOnClear={3}", Name, serviceId, tableName, isDeleteStateOnClear); if (config.Properties.ContainsKey(UseJsonFormatPropertyName)) { useJsonFormat = "true".Equals(config.Properties[UseJsonFormatPropertyName], StringComparison.OrdinalIgnoreCase); } this.jsonSettings = OrleansJsonSerializer.UpdateSerializerSettings(OrleansJsonSerializer.GetDefaultSerializerSettings(), config); initMsg = String.Format("{0} UseJsonFormat={1}", initMsg, useJsonFormat); Log.Info((int)AzureProviderErrorCode.AzureTableProvider_InitProvider, initMsg); Log.Info((int)AzureProviderErrorCode.AzureTableProvider_ParamConnectionString, "AzureTableStorage Provider is using DataConnectionString: {0}", ConfigUtilities.PrintDataConnectionInfo(dataConnectionString)); tableDataManager = new GrainStateTableDataManager(tableName, dataConnectionString, Log); return(tableDataManager.InitTableAsync()); }
private ICollection <IStorageSerializer> ConfigureSerializers(IProviderConfiguration config) { const string @true = "true"; var serializers = new List <IStorageSerializer>(); if (config.Properties.ContainsKey(UseJsonFormatPropertyName) && @true.Equals(config.Properties[UseJsonFormatPropertyName], StringComparison.OrdinalIgnoreCase)) { var jsonSettings = OrleansJsonSerializer.UpdateSerializerSettings(OrleansJsonSerializer.GetDefaultSerializerSettings(), config); serializers.Add(new OrleansStorageDefaultJsonSerializer(jsonSettings, UseJsonFormatPropertyName)); } if (config.Properties.ContainsKey(UseXmlFormatPropertyName) && @true.Equals(config.Properties[UseXmlFormatPropertyName], StringComparison.OrdinalIgnoreCase)) { serializers.Add(new OrleansStorageDefaultXmlSerializer(UseXmlFormatPropertyName)); } if (config.Properties.ContainsKey(UseBinaryFormatPropertyName) && @true.Equals(config.Properties[UseBinaryFormatPropertyName], StringComparison.OrdinalIgnoreCase)) { serializers.Add(new OrleansStorageDefaultBinarySerializer(UseBinaryFormatPropertyName)); } return(serializers); }
private ICollection <IStorageDeserializer> ConfigureDeserializers(IProviderConfiguration config, IProviderRuntime providerRuntime) { const string @true = "true"; var deserializers = new List <IStorageDeserializer>(); if (config.Properties.ContainsKey(UseJsonFormatPropertyName) && @true.Equals(config.Properties[UseJsonFormatPropertyName], StringComparison.OrdinalIgnoreCase)) { var jsonSettings = OrleansJsonSerializer.UpdateSerializerSettings(OrleansJsonSerializer.GetDefaultSerializerSettings(this.serializationManager, providerRuntime.GrainFactory), config); deserializers.Add(new OrleansStorageDefaultJsonDeserializer(jsonSettings, UseJsonFormatPropertyName)); } if (config.Properties.ContainsKey(UseXmlFormatPropertyName) && @true.Equals(config.Properties[UseXmlFormatPropertyName], StringComparison.OrdinalIgnoreCase)) { deserializers.Add(new OrleansStorageDefaultXmlDeserializer(UseXmlFormatPropertyName)); } if (config.Properties.ContainsKey(UseBinaryFormatPropertyName) && @true.Equals(config.Properties[UseBinaryFormatPropertyName], StringComparison.OrdinalIgnoreCase)) { deserializers.Add(new OrleansStorageDefaultBinaryDeserializer(this.serializationManager, UseBinaryFormatPropertyName)); } return(deserializers); }
private ICollection <IStorageDeserializer> ConfigureDeserializers(AdoNetGrainStorageOptions options, IProviderRuntime providerRuntime) { var deserializers = new List <IStorageDeserializer>(); if (options.UseJsonFormat) { var typeResolver = providerRuntime.ServiceProvider.GetRequiredService <ITypeResolver>(); var jsonSettings = OrleansJsonSerializer.UpdateSerializerSettings(OrleansJsonSerializer.GetDefaultSerializerSettings(typeResolver, providerRuntime.GrainFactory), options.UseFullAssemblyNames, options.IndentJson, options.TypeNameHandling); deserializers.Add(new OrleansStorageDefaultJsonDeserializer(jsonSettings, JsonFormatSerializerTag)); } if (options.UseXmlFormat) { deserializers.Add(new OrleansStorageDefaultXmlDeserializer(XmlFormatSerializerTag)); } //if none are set true, configure binary format serializer by default if (!options.UseXmlFormat && !options.UseJsonFormat) { deserializers.Add(new OrleansStorageDefaultBinaryDeserializer(this.serializationManager, BinaryFormatSerializerTag)); } return(deserializers); }
private ICollection <IStorageSerializer> ConfigureSerializers(AdoNetGrainStorageOptions options, IProviderRuntime providerRuntime) { var serializers = new List <IStorageSerializer>(); if (options.UseJsonFormat) { var jsonSettings = OrleansJsonSerializer.UpdateSerializerSettings(OrleansJsonSerializer.GetDefaultSerializerSettings(providerRuntime.ServiceProvider), options.UseFullAssemblyNames, options.IndentJson, options.TypeNameHandling); options.ConfigureJsonSerializerSettings?.Invoke(jsonSettings); serializers.Add(new OrleansStorageDefaultJsonSerializer(jsonSettings, JsonFormatSerializerTag)); } if (options.UseXmlFormat) { serializers.Add(new OrleansStorageDefaultXmlSerializer(XmlFormatSerializerTag)); } //if none are set true, configure binary format serializer by default if (!options.UseXmlFormat && !options.UseJsonFormat) { serializers.Add(new OrleansStorageDefaultBinarySerializer(this.serializer, BinaryFormatSerializerTag)); } return(serializers); }
public GrainReferenceConverter(SerializationManager serializationManager, IGrainFactory grainFactory) { serializerSettings = OrleansJsonSerializer.GetDefaultSerializerSettings(serializationManager, grainFactory); }
public JsonGrainStateSerializer(ITypeResolver typeResolver, IGrainFactory grainFactory) : this(JsonSerializer.Create(OrleansJsonSerializer.GetDefaultSerializerSettings(typeResolver, grainFactory))) { }
/// <summary> Initialization function for this storage provider. </summary> /// <see cref="IProvider#Init"/> public async Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config) { serviceId = providerRuntime.ServiceId.ToString(); Log = providerRuntime.GetLogger("StorageProvider.SimpleSQLServerStorage." + serviceId); try { Name = name; _serializationManager = providerRuntime.ServiceProvider.GetRequiredService <SerializationManager>(); this.jsonSettings = OrleansJsonSerializer.UpdateSerializerSettings(OrleansJsonSerializer.GetDefaultSerializerSettings(_serializationManager, providerRuntime.GrainFactory), config); if (!config.Properties.ContainsKey(CONNECTION_STRING) || string.IsNullOrWhiteSpace(config.Properties[CONNECTION_STRING])) { throw new BadProviderConfigException($"Specify a value for: {CONNECTION_STRING}"); } var connectionString = config.Properties[CONNECTION_STRING]; sqlconnBuilder = new SqlConnectionStringBuilder(connectionString); //a validation of the connection would be wise to perform here var sqlCon = new SqlConnection(sqlconnBuilder.ConnectionString); await sqlCon.OpenAsync(); sqlCon.Close(); //initialize to use the default of JSON storage (this is to provide backwards compatiblity with previous version useJsonOrBinaryFormat = StorageFormatEnum.Binary; if (config.Properties.ContainsKey(USE_JSON_FORMAT_PROPERTY)) { if ("true".Equals(config.Properties[USE_JSON_FORMAT_PROPERTY], StringComparison.OrdinalIgnoreCase)) { useJsonOrBinaryFormat = StorageFormatEnum.Json; } if ("both".Equals(config.Properties[USE_JSON_FORMAT_PROPERTY], StringComparison.OrdinalIgnoreCase)) { useJsonOrBinaryFormat = StorageFormatEnum.Both; } } if (config.Properties.ContainsKey(THROW_ON_DESERIALIZE_ERROR)) { if ("false".Equals(config.Properties[THROW_ON_DESERIALIZE_ERROR], StringComparison.OrdinalIgnoreCase)) { throwOnDeserializeError = false; } } } catch (Exception ex) { Log.Error((int)SimpleSQLServerProviderErrorCodes.SimpleSQLServerProvider_InitProvider, ex.ToString(), ex); throw; } }
protected virtual JsonSerializerSettings ReturnSerializerSettings(ITypeResolver typeResolver, IProviderRuntime providerRuntime, IProviderConfiguration config) { return(OrleansJsonSerializer.UpdateSerializerSettings(OrleansJsonSerializer.GetDefaultSerializerSettings(typeResolver, providerRuntime.GrainFactory), config)); }
/// <summary> /// Initializes a new instance of <see cref="NewtonsoftJsonRedisDataSerializer"/>. /// </summary> /// <param name="typeResolver"></param> /// <param name="grainFactory"></param> /// <param name="configureJsonSerializeSettings"></param> public NewtonsoftJsonRedisDataSerializer(ITypeResolver typeResolver, IGrainFactory grainFactory, Action <JsonSerializerSettings> configureJsonSerializeSettings = null) { _jsonSettings = OrleansJsonSerializer.GetDefaultSerializerSettings(typeResolver, grainFactory); configureJsonSerializeSettings?.Invoke(_jsonSettings); }
/// <summary> /// Initializes the storage provider. /// </summary> /// <param name="name">The name of this provider instance.</param> /// <param name="providerRuntime">A Orleans runtime object managing all storage providers.</param> /// <param name="config">Configuration info for this provider instance.</param> /// <returns>Completion promise for this operation.</returns> public virtual Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config) { this.Log = providerRuntime.GetLogger(this.GetType().FullName); this.serializerSettings = OrleansJsonSerializer.GetDefaultSerializerSettings(); return(TaskDone.Done); }
public GrainReferenceConverter(ITypeResolver typeResolver, IGrainFactory grainFactory) { serializerSettings = OrleansJsonSerializer.GetDefaultSerializerSettings(typeResolver, grainFactory); }
public CosmosDBGrainStorage(string name, CosmosDBStorageOptions options, SerializationManager serializationManager, Providers.IProviderRuntime providerRuntime, IPartitionKeyProvider partitionKeyProvider, IOptions <ClusterOptions> clusterOptions, IGrainFactory grainFactory, ITypeResolver typeResolver, ILoggerFactory loggerFactory) { this._name = name; this._partitionKeyProvider = partitionKeyProvider; this._loggerFactory = loggerFactory; var loggerName = $"{typeof(CosmosDBGrainStorage).FullName}.{name}"; this._logger = loggerFactory.CreateLogger(loggerName); this._options = options; this._serializationManager = serializationManager; this._grainFactory = grainFactory; this._typeResolver = typeResolver; this._serviceId = clusterOptions.Value.ServiceId; this._grainReferenceConverter = providerRuntime.ServiceProvider.GetRequiredService <IGrainReferenceConverter>(); this._sprocFiles = new Dictionary <string, string> { { LOOKUP_INDEX_SPROC, $"{LOOKUP_INDEX_SPROC}.js" } }; if (this._options.JsonSerializerSettings == null) { this._options.JsonSerializerSettings = OrleansJsonSerializer.UpdateSerializerSettings(OrleansJsonSerializer.GetDefaultSerializerSettings(this._typeResolver, this._grainFactory), this._options.UseFullAssemblyNames, this._options.IndentJson, this._options.TypeNameHandling); this._options.JsonSerializerSettings.DefaultValueHandling = DefaultValueHandling.Include; this._options.JsonSerializerSettings.PreserveReferencesHandling = PreserveReferencesHandling.None; } }
/// <summary> /// Constructor /// </summary> public BaseJSONStorageProvider(ILoggerFactory loggerFactory, ITypeResolver typeResolver, IGrainFactory grainFactory) { Log = loggerFactory.CreateLogger(this.GetType().FullName); serializerSettings = OrleansJsonSerializer.GetDefaultSerializerSettings(typeResolver, grainFactory); }