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