public Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
string connectionStringName = config.Properties["ConnectionStringName"];
if (string.IsNullOrEmpty(connectionStringName))
{
this.Log.Info("Starting RavenDB Storage Provider InMemory");
return this.InMemoryMode();
}
var settings = ConfigurationManager.ConnectionStrings[connectionStringName];
var connectionStringBuilder = new DbConnectionStringBuilder
{
ConnectionString = settings.ConnectionString
};
object url;
if (connectionStringBuilder.TryGetValue("Url", out url))
{
this.Log.Info("Starting RavenDB Storage Provider attached to server {0}", url);
return this.ServerMode(connectionStringName);
}
object dataDir;
if (connectionStringBuilder.TryGetValue("DataDir", out dataDir))
{
this.Log.Info("Starting RavenDB Storage Provider embedded in directory {0}", dataDir);
return this.LocalMode(connectionStringName);
}
return TaskDone.Done;
}
/// <summary> Init the factory.</summary>
public virtual void Init(IProviderConfiguration config, string providerName, Logger logger)
{
if (config == null) throw new ArgumentNullException("config");
if (!config.Properties.TryGetValue(DATA_CONNECTION_STRING, out dataConnectionString))
throw new ArgumentException(String.Format("{0} property not set", DATA_CONNECTION_STRING));
if (!config.Properties.TryGetValue(DEPLOYMENT_ID, out deploymentId))
throw new ArgumentException(String.Format("{0} property not set", DEPLOYMENT_ID));
string cacheSizeString;
cacheSize = DEFAULT_CACHE_SIZE;
if (config.Properties.TryGetValue(CACHE_SIZE_PARAM, out cacheSizeString))
{
if (!int.TryParse(cacheSizeString, out cacheSize))
throw new ArgumentException(String.Format("{0} invalid. Must be int", CACHE_SIZE_PARAM));
}
string numQueuesString;
numQueues = DEFAULT_NUM_QUEUES;
if (config.Properties.TryGetValue(NUM_QUEUES_PARAM, out numQueuesString))
{
if (!int.TryParse(numQueuesString, out numQueues))
throw new ArgumentException(String.Format("{0} invalid. Must be int", NUM_QUEUES_PARAM));
}
this.providerName = providerName;
streamQueueMapper = new HashRingBasedStreamQueueMapper(numQueues, providerName);
adapterCache = new SimpleQueueAdapterCache(this, cacheSize, logger);
}
public override async Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
await base.Init(name, providerRuntime, config);
long grainId = GrainCallBootstrapTestConstants.GrainId;
int a = GrainCallBootstrapTestConstants.A;
int b = GrainCallBootstrapTestConstants.B;
ISimpleGrain grain = providerRuntime.GrainFactory.GetGrain<ISimpleGrain>(grainId, SimpleGrain.SimpleGrainNamePrefix);
logger.Info("Setting A={0} on {1}", a, grainId);
await grain.SetA(a);
logger.Info("Setting B={0} on {1}", b, grainId);
await grain.SetB(b);
logger.Info("Getting AxB from {0}", grainId);
int axb = await grain.GetAxB();
logger.Info("Got AxB={0} from {1}", axb, grainId);
int expected = a * b;
int actual = axb;
if (expected != actual) {
throw new Exception(string.Format(
"Value returned to {0} by {1} should be {2} not {3}",
GetType().Name, grainId, expected, actual));
}
}
/// <summary> Init the factory.</summary>
public virtual void Init(IProviderConfiguration config, string providerName, Logger logger, IServiceProvider serviceProvider)
{
if (config == null) throw new ArgumentNullException("config");
if (!config.Properties.TryGetValue(DataConnectionStringPropertyName, out dataConnectionString))
throw new ArgumentException(String.Format("{0} property not set", DataConnectionStringPropertyName));
if (!config.Properties.TryGetValue(DeploymentIdPropertyName, out deploymentId))
throw new ArgumentException(String.Format("{0} property not set", DeploymentIdPropertyName));
cacheSize = SimpleQueueAdapterCache.ParseSize(config, CacheSizeDefaultValue);
string numQueuesString;
numQueues = NumQueuesDefaultValue;
if (config.Properties.TryGetValue(NumQueuesPropertyName, out numQueuesString))
{
if (!int.TryParse(numQueuesString, out numQueues))
throw new ArgumentException(String.Format("{0} invalid. Must be int", NumQueuesPropertyName));
}
this.providerName = providerName;
streamQueueMapper = new HashRingBasedStreamQueueMapper(numQueues, providerName);
adapterCache = new SimpleQueueAdapterCache(cacheSize, logger);
if (StreamFailureHandlerFactory == null)
{
StreamFailureHandlerFactory =
qid => Task.FromResult<IStreamFailureHandler>(new NoOpStreamDeliveryFailureHandler(false));
}
}
public async Task Init( string name, IProviderRuntime providerRuntime, IProviderConfiguration config )
{
Log = providerRuntime.GetLogger( this.GetType().Name );
try
{
ConfigureJsonSerializerSettings( config );
if( !config.Properties.ContainsKey( "DataConnectionString" ) )
{
throw new BadProviderConfigException(
"The DataConnectionString setting has not been configured in the cloud role. Please add a DataConnectionString setting with a valid Azure Storage connection string." );
}
else
{
var account = CloudStorageAccount.Parse( config.Properties[ "DataConnectionString" ] );
var blobClient = account.CreateCloudBlobClient();
var containerName = config.Properties.ContainsKey( "ContainerName" ) ? config.Properties[ "ContainerName" ] : "grainstate";
container = blobClient.GetContainerReference( containerName );
await container.CreateIfNotExistsAsync();
}
}
catch( Exception ex )
{
Log.Error( 0, ex.ToString(), ex );
throw;
}
}
/// <summary> Initialization function for this storage provider. </summary>
/// <see cref="IProvider.Init"/>
public async Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
Log = providerRuntime.GetLogger("Storage.AzureBlobStorage");
try
{
this.Name = name;
ConfigureJsonSerializerSettings(config);
if (!config.Properties.ContainsKey("DataConnectionString")) throw new BadProviderConfigException("The DataConnectionString setting has not been configured in the cloud role. Please add a DataConnectionString setting with a valid Azure Storage connection string.");
var account = CloudStorageAccount.Parse(config.Properties["DataConnectionString"]);
var blobClient = account.CreateCloudBlobClient();
var containerName = config.Properties.ContainsKey("ContainerName") ? config.Properties["ContainerName"] : "grainstate";
container = blobClient.GetContainerReference(containerName);
await container.CreateIfNotExistsAsync().ConfigureAwait(false);
Log.Info((int)AzureProviderErrorCode.AzureBlobProvider_InitProvider, "Init: Name={0} ServiceId={1} {2}", name, providerRuntime.ServiceId.ToString(), string.Join(" ", FormatPropertyMessage(config)));
Log.Info((int)AzureProviderErrorCode.AzureBlobProvider_ParamConnectionString, "AzureBlobStorage Provider is using DataConnectionString: {0}", ConfigUtilities.PrintDataConnectionInfo(config.Properties["DataConnectionString"]));
}
catch (Exception ex)
{
Log.Error((int)AzureProviderErrorCode.AzureBlobProvider_InitProvider, ex.ToString(), ex);
throw;
}
}
public Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
this.logger = providerRuntime.GetLogger("Dashboard");
var router = new Router();
new DashboardController(router, TaskScheduler.Current, providerRuntime);
var options = new StartOptions
{
ServerFactory = "Nowin",
Port = config.Properties.ContainsKey("Port") ? int.Parse(config.Properties["Port"]) : 8080,
};
var username = config.Properties.ContainsKey("Username") ? config.Properties["Username"] : null;
var password = config.Properties.ContainsKey("Password") ? config.Properties["Password"] : null;
try
{
host = WebApp.Start(options, app => new WebServer(router, username, password).Configuration(app));
}
catch (Exception ex)
{
this.logger.Error(10001, ex.ToString());
}
this.logger.Verbose($"Dashboard listening on {options.Port}");
this.profiler = new GrainProfiler(TaskScheduler.Current, providerRuntime);
var dashboardGrain = providerRuntime.GrainFactory.GetGrain<IDashboardGrain>(0);
return dashboardGrain.Init();
}
public void Init(IProviderConfiguration config, string providerName, Logger logger, IServiceProvider serviceProvider)
{
if (config == null) throw new ArgumentNullException(nameof(config));
if (logger == null) throw new ArgumentNullException(nameof(logger));
if (String.IsNullOrEmpty(providerName)) throw new ArgumentNullException(nameof(providerName));
// Creating an options object with all the config values
_options = new KafkaStreamProviderOptions(config);
if (!_options.UsingExternalMetrics)
{
Metric.Config.WithHttpEndpoint($"http://localhost:{_options.MetricsPort}/");
}
if (!_options.IncludeMetrics)
{
Metric.Context("KafkaStreamProvider").Advanced.CompletelyDisableMetrics();
}
_providerName = providerName;
_streamQueueMapper = new HashRingBasedStreamQueueMapper(_options.NumOfQueues, providerName);
_logger = logger;
_adapter = new KafkaQueueAdapter(_streamQueueMapper, _options, providerName, new KafkaBatchFactory(), _logger);
_adapterCache = new TimedQueueAdapterCache(this, TimeSpan.FromSeconds(_options.CacheTimespanInSeconds), _options.CacheSize, _options.CacheNumOfBuckets, logger);
}
/// <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(DATA_CONNECTION_STRING) || string.IsNullOrWhiteSpace(config.Properties[DATA_CONNECTION_STRING]))
throw new ArgumentException("DataConnectionString property not set");
dataConnectionString = config.Properties["DataConnectionString"];
if (config.Properties.ContainsKey(TABLE_NAME_PROPERTY))
tableName = config.Properties[TABLE_NAME_PROPERTY];
isDeleteStateOnClear = config.Properties.ContainsKey(DELETE_ON_CLEAR_PROPERTY) &&
"true".Equals(config.Properties[DELETE_ON_CLEAR_PROPERTY], 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(USE_JSON_FORMAT_PROPERTY))
useJsonFormat = "true".Equals(config.Properties[USE_JSON_FORMAT_PROPERTY], StringComparison.OrdinalIgnoreCase);
if (useJsonFormat)
{
jsonSettings = jsonSettings = OrleansJsonSerializer.SerializerSettings;
}
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();
}
public Task Init(Logger logger, IProviderConfiguration config, string providerName, int numQueues)
{
_logger = logger;
_queues = new ConcurrentDictionary<QueueId, Queue<byte[]>>();
IsInitialised = true;
return TaskDone.Done;
}
public Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
//process uncommit event message(store uncommit event message to event-store)
//var eventDispatcher = GrainFactory.GetGrain<IEventStoreDispatcher>(0);
GrainInternalEventHandlerProvider.RegisterInternalEventHandler(this.GetType().Assembly);
return TaskDone.Done;
}
/// <summary>
/// Initializes the provider during silo startup.
/// </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 override Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
this.Name = name;
this.RootDirectory = config.Properties["RootDirectory"];
if (string.IsNullOrWhiteSpace(RootDirectory)) throw new ArgumentException("RootDirectory property not set");
DataManager = new GrainStateFileDataManager(RootDirectory);
return base.Init(name, providerRuntime, config);
}
public virtual void PopulateFromProviderConfig(IProviderConfiguration providerConfiguration)
{
EventHubSettingsType = providerConfiguration.GetTypeProperty(EventHubConfigTypeName, null);
if (string.IsNullOrWhiteSpace(StreamProviderName))
{
throw new ArgumentOutOfRangeException("providerConfiguration", "StreamProviderName not set.");
}
}
// used only for testing
internal async Task AddAndInitProvider(string name, IProvider provider, IProviderConfiguration config = null)
{
if (provider != null)
{
await provider.Init(name, this, config);
statisticsProviderLoader.AddProvider(name, provider, config);
}
}
public virtual Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
Name = name;
logger = providerRuntime.GetLogger(GetType().Name);
logger.Info("Init Name={0}", Name);
Interlocked.Increment(ref initCount);
return TaskDone.Done;
}
//---------------------------------------------------------------------
public async Task Init(string name, IProviderRuntime provider_runtime, IProviderConfiguration config)
{
Console.Title = "GameCloud.IM v1.00.000 build20161014";
Console.WriteLine("GameCloud.IM v1.00.000 build20161014");
var startup = new IMStartup();
await startup.Start();
}
/// <summary>
/// Utility function to populate config from provider config
/// </summary>
/// <param name="providerConfiguration"></param>
public virtual void PopulateFromProviderConfig(IProviderConfiguration providerConfiguration)
{
GeneratorConfigType = providerConfiguration.GetTypeProperty(GeneratorConfigTypeName, null);
if (string.IsNullOrWhiteSpace(StreamProviderName))
{
throw new ArgumentOutOfRangeException("providerConfiguration", "StreamProviderName not set.");
}
TotalQueueCount = providerConfiguration.GetIntProperty(TotalQueueCountName, TotalQueueCountDefault);
}
/// <summary> Init the factory.</summary>
public virtual void Init(IProviderConfiguration config, string providerName, Logger logger, IServiceProvider serviceProvider)
{
if (config == null) throw new ArgumentNullException("config");
if (!config.Properties.TryGetValue(AzureQueueAdapterFactory.DATA_CONNECTION_STRING, out dataConnectionString))
throw new ArgumentException(String.Format("{0} property not set", AzureQueueAdapterFactory.DATA_CONNECTION_STRING));
if (!config.Properties.TryGetValue(QUEUE_NAME_STRING, out queueName))
throw new ArgumentException(String.Format("{0} property not set", QUEUE_NAME_STRING));
this.providerName = providerName;
}
/// <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 override Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
this.Name = name;
this.ConnectionString = config.Properties["ConnectionString"];
this.Database = config.Properties["Database"];
if (string.IsNullOrWhiteSpace(ConnectionString)) throw new ArgumentException("ConnectionString property not set");
if (string.IsNullOrWhiteSpace(Database)) throw new ArgumentException("Database property not set");
DataManager = new GrainStateMongoDataManager(Database, ConnectionString);
return base.Init(name, providerRuntime, config);
}
public async Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
Name = name;
logger = providerRuntime.GetLogger("SqlStatisticsPublisher");
//TODO: Orleans does not yet provide the type of database used (to, e.g., to load dlls), so SQL Server is assumed.
database = RelationalStorageUtilities.CreateGenericStorageInstance(WellKnownRelationalInvariants.SqlServer, config.Properties["ConnectionString"]);
await InitOrleansQueriesAsync();
}
public Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
providerRuntime.SetInvokeInterceptor((method, request, grain, invoker) =>
{
RequestContext.Set("GrainInfo", 38);
return invoker.Invoke(grain, request);
});
return Task.FromResult(0);
}
public async Task Init(Logger logger, IProviderConfiguration config, string providerName, int numQueues)
{
_logger = logger;
_redisListBaseName = $"orleans-{providerName}-queue";
ReadRedisConnectionParams(config);
_connection = await ConnectionMultiplexer.ConnectAsync(_server);
_database = _connection.GetDatabase(_databaseNum);
logger.AutoInfo($"connection to Redis successful.");
IsInitialised = true;
}
public void PopulateFromProviderConfig(IProviderConfiguration providerConfiguration)
{
EventHubSettingsType = providerConfiguration.GetTypeProperty(EventHubConfigTypeName, null);
CheckpointSettingsType = providerConfiguration.GetTypeProperty(CheckpointSettingsTypeName, null);
if (string.IsNullOrWhiteSpace(StreamProviderName))
{
throw new ArgumentOutOfRangeException("providerConfiguration", "StreamProviderName not set.");
}
CacheSizeMb = providerConfiguration.GetIntProperty(CacheSizeMbName, DefaultCacheSizeMb);
}
/// <summary>
/// Initializes publisher
/// </summary>
/// <param name="name">Provider name</param>
/// <param name="providerRuntime">Provider runtime API</param>
/// <param name="config">Provider configuration</param>
/// <returns></returns>
public async Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
Name = name;
logger = providerRuntime.GetLogger("SqlStatisticsPublisher");
string adoInvariant = AdoNetInvariants.InvariantNameSqlServer;
if (config.Properties.ContainsKey("AdoInvariant"))
adoInvariant = config.Properties["AdoInvariant"];
orleansQueries = await RelationalOrleansQueries.CreateInstance(adoInvariant, config.Properties["ConnectionString"]);
}
public override async Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
await base.Init(name, providerRuntime, config);
string latencyParam = config.Properties[LATENCY_PARAM_STRING];
latency = latencyParam == null ? DefaultLatency : TimeSpan.Parse(latencyParam);
Log.Info("Init: Fixed Store Latency={0}", latency);
mockCallsOnly = config.Properties.ContainsKey(MOCK_CALLS_PARAM_STRING) &&
"true".Equals(config.Properties[MOCK_CALLS_PARAM_STRING], StringComparison.OrdinalIgnoreCase);
}
private void ConfigureJsonSerializerSettings( IProviderConfiguration config )
{
// By default, use automatic type name handling, simple assembly names, and no JSON formatting
settings = new JsonSerializerSettings {
TypeNameHandling = TypeNameHandling.Auto,
TypeNameAssemblyFormat = FormatterAssemblyStyle.Simple,
Formatting = Formatting.None
};
if( config.Properties.ContainsKey( "SerializeTypeNames" ) )
{
bool serializeTypeNames = false;
var serializeTypeNamesValue = config.Properties[ "SerializeTypeNames" ];
bool.TryParse( serializeTypeNamesValue, out serializeTypeNames );
if( serializeTypeNames )
{
settings.TypeNameHandling = TypeNameHandling.All;
}
}
if (config.Properties.ContainsKey("PreserveReferencesHandling"))
{
bool preserveReferencesHandling;
var preserveReferencesHandlingValue = config.Properties["PreserveReferencesHandling"];
bool.TryParse(preserveReferencesHandlingValue, out preserveReferencesHandling);
if (preserveReferencesHandling)
{
settings.PreserveReferencesHandling = PreserveReferencesHandling.Objects;
}
}
if( config.Properties.ContainsKey( "UseFullAssemblyNames" ) )
{
bool useFullAssemblyNames = false;
var UseFullAssemblyNamesValue = config.Properties[ "UseFullAssemblyNames" ];
bool.TryParse( UseFullAssemblyNamesValue, out useFullAssemblyNames );
if( useFullAssemblyNames )
{
settings.TypeNameAssemblyFormat = FormatterAssemblyStyle.Full;
}
}
if( config.Properties.ContainsKey( "IndentJSON" ) )
{
bool indentJSON = false;
var indentJSONValue = config.Properties[ "IndentJSON" ];
bool.TryParse( indentJSONValue, out indentJSON );
if( indentJSON )
{
settings.Formatting = Formatting.Indented;
}
}
}
public Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
var system = ClusterActorSystem.Current;
var providers = config.Properties["providers"].Split(';');
StreamPubSubWrapper.Hook(providers, stream =>
StreamSubscriptionMatcher
.Match(system, stream)
.Select(x => new StreamPubSubMatch(x.Receive))
.ToArray());
return TaskDone.Done;
}
//---------------------------------------------------------------------
public async Task Init(string name, IProviderRuntime provider_runtime, IProviderConfiguration config)
{
Console.Title = "GameCloud.IM.Test.App v1.00.000";
Console.WriteLine("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
Console.WriteLine("IMTestAppOrleansBootstrap.Init()");
Console.WriteLine("!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!");
IMTestAppContext.Instance.Setup();
var grain_player = provider_runtime.GrainFactory.GetGrain<IGrainIMTestAppPlayer>(Guid.NewGuid());
await grain_player.Setup();
}
public async Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
Name = name;
logger = providerRuntime.GetLogger("SqlStatisticsPublisher");
string adoInvariant = AdoNetInvariants.InvariantNameSqlServer;
if (config.Properties.ContainsKey("AdoInvariant"))
adoInvariant = config.Properties["AdoInvariant"];
database = RelationalStorageUtilities.CreateGenericStorageInstance(adoInvariant, config.Properties["ConnectionString"]);
queryConstants = await database.InitializeOrleansQueriesAsync();
}
public Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
Log = providerRuntime.GetLogger(this.GetType().FullName);
ConnectString = config.Properties["DataConnectionString"];
if (config.Properties.ContainsKey("Table"))
{
Table = config.Properties["Table"];
CustomTable = true;
}
return TaskDone.Done;
}
/// <summary>
/// Cria uma instancia com o provedor de configuração.
/// </summary>
/// <param name="providerConfiguration">Instancia do provedor de configuração.</param>
/// <param name="isolationLevel"></param>
public GDATransaction(IProviderConfiguration providerConfiguration, IsolationLevel isolationLevel) : base(providerConfiguration)
{
_isolationLevel = isolationLevel;
}
/// <summary>
/// Cria uma instancia com o provedor de configuração.
/// </summary>
/// <param name="providerConfiguration">Instancia do provedor de configuração.</param>
public GDATransaction(IProviderConfiguration providerConfiguration) : this(providerConfiguration, IsolationLevel.Unspecified)
{
}
/// <summary>
/// Utility function to populate config from provider config
/// </summary>
/// <param name="providerConfiguration"></param>
public void PopulateFromProviderConfig(IProviderConfiguration providerConfiguration)
{
TotalQueueCount = providerConfiguration.GetIntProperty(TotalQueueCountName, TotalQueueCountDefault);
}
/// <summary>
/// Customises the given serializer settings using provider configuration.
/// Can be used by any provider, allowing the users to use a standard set of configuration attributes.
/// </summary>
/// <param name="settings">The settings to update.</param>
/// <param name="config">The provider config.</param>
/// <returns>The updated <see cref="JsonSerializerSettings" />.</returns>
public static JsonSerializerSettings UpdateSerializerSettings(JsonSerializerSettings settings, IProviderConfiguration config)
{
bool useFullAssemblyNames = config.GetBoolProperty(UseFullAssemblyNamesProperty, false);
bool indentJson = config.GetBoolProperty(IndentJsonProperty, false);
TypeNameHandling typeNameHandling = config.GetEnumProperty(TypeNameHandlingProperty, settings.TypeNameHandling);
return(UpdateSerializerSettings(settings, useFullAssemblyNames, indentJson, typeNameHandling));
}
public override async Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
await base.Init(name, providerRuntime, config);
serviceId = providerRuntime.ServiceId;
siloId = providerRuntime.SiloIdentity;
logger.Info("Finished Init instance id {0} on silo {1} in service {2}", myId, siloId, serviceId);
}
/// <summary>
/// Parce the size property from configuration
/// </summary>
/// <param name="config"></param>
/// <param name="defaultSize"></param>
/// <returns></returns>
public static int ParseSize(IProviderConfiguration config, int defaultSize)
{
return(config.GetIntProperty(CacheSizePropertyName, defaultSize));
}
/// <summary>
/// Retrieves an existing provider configuration
/// </summary>
/// <param name="providerTypeFullName">Full name of the stream provider type</param>
/// <param name="providerName">Name of the stream provider</param>
/// <param name="config">The provider configuration, if exists</param>
/// <returns>True if a configuration for this provider already exists, false otherwise.</returns>
public bool TryGetProviderConfiguration(string providerTypeFullName, string providerName, out IProviderConfiguration config)
{
return(ProviderConfigurationUtility.TryGetProviderConfiguration(ProviderConfigurations, providerTypeFullName, providerName, out config));
}
public static int ParseSize(IProviderConfiguration config, int defaultSize)
{
return(config.GetIntProperty(CACHE_SIZE_PARAM, defaultSize));
}
/// <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)
{
Log = providerRuntime.GetLogger(this.GetType().FullName);
return(TaskDone.Done);
}
//---------------------------------------------------------------------
public async Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
EntityMgr = new EntityMgr((byte)NodeType.Cell, NodeType.Cell.ToString());
EntityMgr.regComponent <CellActor <DefActor> >();
EntityMgr.regComponent <CellActorMirror <DefActorMirror> >();
EntityMgr.regComponent <CellActorMirrorAi <DefActorMirrorAi> >();
EntityMgr.regComponent <CellBag <DefBag> >();
EntityMgr.regComponent <CellDesktop <DefDesktop> >();
EntityMgr.regComponent <CellEquip <DefEquip> >();
EntityMgr.regComponent <CellPlayer <DefPlayer> >();
EntityMgr.regComponent <CellPlayerChat <DefPlayerChat> >();
EntityMgr.regComponent <CellPlayerDesktop <DefPlayerDesktop> >();
EntityMgr.regComponent <CellPlayerFriend <DefPlayerFriend> >();
EntityMgr.regComponent <CellPlayerLobby <DefPlayerLobby> >();
EntityMgr.regComponent <CellPlayerMailBox <DefPlayerMailBox> >();
EntityMgr.regComponent <CellPlayerTask <DefPlayerTask> >();
EntityMgr.regComponent <CellPlayerTrade <DefPlayerTrade> >();
EntityMgr.regComponent <CellPlayerRanking <DefPlayerRanking> >();
EntityMgr.regComponent <CellStatus <DefStatus> >();
EntityMgr.regEntityDef <EtDesktop>();
EntityMgr.regEntityDef <EtPlayer>();
EntityMgr.regEntityDef <EtPlayerMirror>();
DbClientCouchbase = new DbClientCouchbase();
EntityCouchbase et_couchbase = new EntityCouchbase(EntityMgr, DbClientCouchbase.Bucket);
// 创建视图
//var couchbase_mgr = DbClientCouchbase.Instance.Bucket.CreateManager("Cragon", "123321");
//var get = couchbase_mgr.GetDesignDocument("dev_team");
//if (!get.Success)
//{
// var design_doc = File.ReadAllText(@"..\\..\\..\\Media\\Fishing\\CouchbaseView\\dev_team.json");
// var inserted = couchbase_mgr.InsertDesignDocument("dev_team", design_doc);
// if (inserted.Success)
// {
// EbLog.Note("Created 'team' design doc. Success");
// }
// else
// {
// EbLog.Note("Created 'team' design doc. Failed, Msg=" + inserted.Message);
// }
//}
// 初始化DataMgr
{
string path_media = ServerPath.getPathMediaRoot();
string db_filename = Path.Combine(path_media, "Fishing\\Config\\Fishing.db");
EbLog.Note(db_filename);
TbDataMgr.setup(db_filename);
}
// 初始化单位模块
UnitSys.setup(false);
// 初始化效果系统
EffectSys.regEffect(new EffectCreateStatus());
EffectSys.regEffect(new EffectStatus1());
EffectSys.regEffect(new EffectStatus2());
EffectSys.regEffect(new EffectStatusCreator1());
EffectSys.regEffect(new EffectStatusCreator2());
EffectSys.regEffect(new EffectTakeoffEquip());
EffectSys.regEffect(new EffectTakeonEquip());
EffectSys.regEffect(new EffectUseConsumable());
EffectSys.regEffect(new EffectUseSkillBook());
// 初始化CellApp
CellApp = new CellApp();
//// 加载所有Bot
//var map_databot = EbDataMgr.Instance.getMapData<TbDataBot>();
//foreach (var i in map_databot)
//{
// TbDataBot data_bot = (TbDataBot)i.Value;
// //var grain_player = CellPlayerFactory.GetGrain(new Guid(data_bot.EtGuid));
// //var grain_player = GrainFactory.GetGrain<ICellPlayer>(new Guid(data_bot.EtGuid));
// //await grain_player.botNewAndEnterWorld(data_bot.NickName);
//}
//return TaskDone.Done;
}
//---------------------------------------------------------------------
public Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
EntityMgr = new EntityMgr((byte)NodeType.Cell, NodeType.Cell.ToString());
EntityMgr.regComponent <CellActor <DefActor> >();
EntityMgr.regComponent <CellActorMirror <DefActorMirror> >();
EntityMgr.regComponent <CellActorMirrorAi <DefActorMirrorAi> >();
EntityMgr.regComponent <CellBag <DefBag> >();
EntityMgr.regComponent <CellDesktop <DefDesktop> >();
EntityMgr.regComponent <CellEquip <DefEquip> >();
EntityMgr.regComponent <CellPlayer <DefPlayer> >();
EntityMgr.regComponent <CellPlayerChat <DefPlayerChat> >();
EntityMgr.regComponent <CellPlayerDesktop <DefPlayerDesktop> >();
EntityMgr.regComponent <CellPlayerFriend <DefPlayerFriend> >();
EntityMgr.regComponent <CellPlayerLobby <DefPlayerLobby> >();
EntityMgr.regComponent <CellPlayerMailBox <DefPlayerMailBox> >();
EntityMgr.regComponent <CellPlayerTask <DefPlayerTask> >();
EntityMgr.regComponent <CellPlayerTrade <DefPlayerTrade> >();
EntityMgr.regComponent <CellPlayerRanking <DefPlayerRanking> >();
EntityMgr.regComponent <CellStatus <DefStatus> >();
EntityMgr.regEntityDef <EtDesktop>();
EntityMgr.regEntityDef <EtPlayer>();
EntityMgr.regEntityDef <EtPlayerMirror>();
// 初始化DataMgr
{
string path_media = ServerPath.getPathMediaRoot();
string db_filename = Path.Combine(path_media, "Fishing\\Config\\Fishing.db");
EbLog.Note(db_filename);
TbDataMgr.setup(db_filename);
}
// 初始化单位模块
UnitSys.setup(false);
// 初始化效果系统
EffectSys.regEffect(new EffectCreateStatus());
EffectSys.regEffect(new EffectStatus1());
EffectSys.regEffect(new EffectStatus2());
EffectSys.regEffect(new EffectStatusCreator1());
EffectSys.regEffect(new EffectStatusCreator2());
EffectSys.regEffect(new EffectTakeoffEquip());
EffectSys.regEffect(new EffectTakeonEquip());
EffectSys.regEffect(new EffectUseConsumable());
EffectSys.regEffect(new EffectUseSkillBook());
// 初始化CellApp
CellApp = new CellApp();
//// 加载所有Bot
//var map_databot = EbDataMgr.Instance.getMapData<TbDataBot>();
//foreach (var i in map_databot)
//{
// TbDataBot data_bot = (TbDataBot)i.Value;
// //var grain_player = CellPlayerFactory.GetGrain(new Guid(data_bot.EtGuid));
// //var grain_player = GrainFactory.GetGrain<ICellPlayer>(new Guid(data_bot.EtGuid));
// //await grain_player.botNewAndEnterWorld(data_bot.NickName);
//}
return(TaskDone.Done);
}
private async Task SendAndReceiveFromQueueAdapter(IQueueAdapterFactory adapterFactory, IProviderConfiguration config)
{
IQueueAdapter adapter = await adapterFactory.CreateAdapter();
IQueueAdapterCache cache = adapterFactory.GetQueueAdapterCache();
// Create receiver per queue
IStreamQueueMapper mapper = adapterFactory.GetStreamQueueMapper();
Dictionary <QueueId, IQueueAdapterReceiver> receivers = mapper.GetAllQueues().ToDictionary(queueId => queueId, adapter.CreateReceiver);
Dictionary <QueueId, IQueueCache> caches = mapper.GetAllQueues().ToDictionary(queueId => queueId, cache.CreateQueueCache);
await Task.WhenAll(receivers.Values.Select(receiver => receiver.Initialize(TimeSpan.FromSeconds(5))));
// test using 2 streams
Guid streamId1 = Guid.NewGuid();
Guid streamId2 = Guid.NewGuid();
int receivedBatches = 0;
var streamsPerQueue = new ConcurrentDictionary <QueueId, HashSet <IStreamIdentity> >();
// reader threads (at most 2 active queues because only two streams)
var work = new List <Task>();
foreach (KeyValuePair <QueueId, IQueueAdapterReceiver> receiverKvp in receivers)
{
QueueId queueId = receiverKvp.Key;
var receiver = receiverKvp.Value;
var qCache = caches[queueId];
Task task = Task.Factory.StartNew(() =>
{
while (receivedBatches < NumBatches)
{
var messages = receiver.GetQueueMessagesAsync(SQSStorage.MAX_NUMBER_OF_MESSAGE_TO_PEAK).Result.ToArray();
if (!messages.Any())
{
continue;
}
foreach (var message in messages.Cast <SQSBatchContainer>())
{
streamsPerQueue.AddOrUpdate(queueId,
id => new HashSet <IStreamIdentity> {
new StreamIdentity(message.StreamGuid, message.StreamGuid.ToString())
},
(id, set) =>
{
set.Add(new StreamIdentity(message.StreamGuid, message.StreamGuid.ToString()));
return(set);
});
output.WriteLine("Queue {0} received message on stream {1}", queueId,
message.StreamGuid);
Assert.Equal(NumMessagesPerBatch / 2, message.GetEvents <int>().Count()); // "Half the events were ints"
Assert.Equal(NumMessagesPerBatch / 2, message.GetEvents <string>().Count()); // "Half the events were strings"
}
Interlocked.Add(ref receivedBatches, messages.Length);
qCache.AddToCache(messages);
}
});
work.Add(task);
}
// send events
List <object> events = CreateEvents(NumMessagesPerBatch);
work.Add(Task.Factory.StartNew(() => Enumerable.Range(0, NumBatches)
.Select(i => i % 2 == 0 ? streamId1 : streamId2)
.ToList()
.ForEach(streamId =>
adapter.QueueMessageBatchAsync(streamId, streamId.ToString(),
events.Take(NumMessagesPerBatch).ToArray(), null, RequestContext.Export(this.fixture.SerializationManager)).Wait())));
await Task.WhenAll(work);
// Make sure we got back everything we sent
Assert.Equal(NumBatches, receivedBatches);
// check to see if all the events are in the cache and we can enumerate through them
StreamSequenceToken firstInCache = new EventSequenceTokenV2(0);
foreach (KeyValuePair <QueueId, HashSet <IStreamIdentity> > kvp in streamsPerQueue)
{
var receiver = receivers[kvp.Key];
var qCache = caches[kvp.Key];
foreach (IStreamIdentity streamGuid in kvp.Value)
{
// read all messages in cache for stream
IQueueCacheCursor cursor = qCache.GetCacheCursor(streamGuid, firstInCache);
int messageCount = 0;
StreamSequenceToken tenthInCache = null;
StreamSequenceToken lastToken = firstInCache;
while (cursor.MoveNext())
{
Exception ex;
messageCount++;
IBatchContainer batch = cursor.GetCurrent(out ex);
output.WriteLine("Token: {0}", batch.SequenceToken);
Assert.True(batch.SequenceToken.CompareTo(lastToken) >= 0, $"order check for event {messageCount}");
lastToken = batch.SequenceToken;
if (messageCount == 10)
{
tenthInCache = batch.SequenceToken;
}
}
output.WriteLine("On Queue {0} we received a total of {1} message on stream {2}", kvp.Key, messageCount, streamGuid);
Assert.Equal(NumBatches / 2, messageCount);
Assert.NotNull(tenthInCache);
// read all messages from the 10th
cursor = qCache.GetCacheCursor(streamGuid, tenthInCache);
messageCount = 0;
while (cursor.MoveNext())
{
messageCount++;
}
output.WriteLine("On Queue {0} we received a total of {1} message on stream {2}", kvp.Key, messageCount, streamGuid);
const int expected = NumBatches / 2 - 10 + 1; // all except the first 10, including the 10th (10 + 1)
Assert.Equal(expected, messageCount);
}
}
}
internal static bool TryGetProviderConfiguration(IDictionary <string, ProviderCategoryConfiguration> providerConfigurations,
string providerTypeFullName, string providerName, out IProviderConfiguration config)
{
foreach (ProviderCategoryConfiguration category in providerConfigurations.Values)
{
foreach (IProviderConfiguration providerConfig in category.Providers.Values)
{
if (providerConfig.Type.Equals(providerTypeFullName) && providerConfig.Name.Equals(providerName))
{
config = providerConfig;
return(true);
}
}
}
config = null;
return(false);
}
/// <summary> Initialization function for this storage provider. </summary>
/// <see cref="IProvider.Init"/>
public async Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
if (string.IsNullOrWhiteSpace(name))
{
throw new ArgumentException("The parameter must contain characters", nameof(name));
}
if (providerRuntime == null)
{
throw new ArgumentNullException(nameof(providerRuntime));
}
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
if (!config.Properties.ContainsKey(DataConnectionStringPropertyName))
{
throw new BadProviderConfigException($"The {DataConnectionStringPropertyName} setting has not been configured. Add a {DataConnectionStringPropertyName} setting with a valid connection string.");
}
this.serializationManager = providerRuntime.ServiceProvider.GetRequiredService <SerializationManager>();
//NOTE: StorageSerializationPicker should be defined outside and given as a parameter in constructor or via Init in IProviderConfiguration perhaps.
//Currently this limits one's options to much to the current situation of providing only one serializer for serialization and deserialization
//with no regard to state update or serializer changes. Maybe have this serialized as a JSON in props and read via a key?
StorageSerializationPicker = new DefaultRelationalStoragePicker(this.ConfigureDeserializers(config, providerRuntime), this.ConfigureSerializers(config, providerRuntime));
//NOTE: Currently there should be only one pair of providers given. That is, only UseJsonFormatPropertyName, UseXmlFormatPropertyName or UseBinaryFormatPropertyName.
if (StorageSerializationPicker.Deserializers.Count > 1 || StorageSerializationPicker.Serializers.Count > 1)
{
throw new ArgumentException("Configuration error, only one serializer and deserializer should be given.", nameof(config));
}
if (StorageSerializationPicker.Deserializers.Count == 0 || StorageSerializationPicker.Serializers.Count == 0)
{
StorageSerializationPicker.Deserializers.Add(new OrleansStorageDefaultBinaryDeserializer(this.serializationManager, UseBinaryFormatPropertyName));
StorageSerializationPicker.Serializers.Add(new OrleansStorageDefaultBinarySerializer(this.serializationManager, UseBinaryFormatPropertyName));
}
var connectionInvariant = config.Properties.ContainsKey(DataConnectionInvariantPropertyName) ? config.Properties[DataConnectionInvariantPropertyName] : DefaultAdoInvariantInvariantPropertyName;
Storage = RelationalStorage.CreateInstance(connectionInvariant, config.Properties[DataConnectionStringPropertyName]);
ServiceId = providerRuntime.ServiceId.ToString();
var queries = await Storage.ReadAsync(DefaultInitializationQuery, command => { }, (selector, resultSetCount, token) =>
{
return(Task.FromResult(Tuple.Create(selector.GetValue <string>("QueryKey"), selector.GetValue <string>("QueryText"))));
}).ConfigureAwait(false);
CurrentOperationalQueries = new RelationalStorageProviderQueries(
queries.Single(i => i.Item1 == "WriteToStorageKey").Item2,
queries.Single(i => i.Item1 == "ReadFromStorageKey").Item2,
queries.Single(i => i.Item1 == "ClearStorageKey").Item2);
var loggerFactory = providerRuntime.ServiceProvider.GetService <ILoggerFactory>();
this.logger = loggerFactory.CreateLogger <AdoNetStorageProvider>();
Name = name;
logger.Info((int)RelationalStorageProviderCodes.RelationalProviderInitProvider, $"Initialized storage provider: ServiceId={ServiceId} ProviderName={Name} Invariant={Storage.InvariantName} ConnectionString={Storage.ConnectionString}.");
}
public override async Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
await base.Init(name, providerRuntime, config);
long grainId = GrainCallBootstrapTestConstants.GrainId;
int a = GrainCallBootstrapTestConstants.A;
int b = GrainCallBootstrapTestConstants.B;
ISimpleGrain grain = providerRuntime.GrainFactory.GetGrain <ISimpleGrain>(grainId, SimpleGrain.SimpleGrainNamePrefix);
logger.Info("Setting A={0} on {1}", a, grainId);
await grain.SetA(a);
logger.Info("Setting B={0} on {1}", b, grainId);
await grain.SetB(b);
logger.Info("Getting AxB from {0}", grainId);
int axb = await grain.GetAxB();
logger.Info("Got AxB={0} from {1}", axb, grainId);
int expected = a * b;
int actual = axb;
if (expected != actual)
{
throw new Exception(string.Format(
"Value returned to {0} by {1} should be {2} not {3}",
GetType().Name, grainId, expected, actual));
}
}
public Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
#pragma warning disable 618
return(Task.FromResult(0));
}
public override async Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
await base.Init(name, providerRuntime, config);
ILocalContentGrain grain = providerRuntime.GrainFactory.GetGrain <ILocalContentGrain>(Guid.NewGuid());
// issue any grain call to activate this grain.
await grain.Init();
logger.Info("Finished Init Name={0}", name);
}
public virtual void Init(IProviderConfiguration config, string providerName, Logger logger, IServiceProvider serviceProvider)
{
if (config == null)
{
throw new ArgumentNullException(nameof(config));
}
if (!config.Properties.TryGetValue(PubSubAdapterConstants.PROJECT_ID, out _projectId))
{
throw new ArgumentException($"{PubSubAdapterConstants.PROJECT_ID} property not set");
}
if (!config.Properties.TryGetValue(PubSubAdapterConstants.TOPIC_ID, out _topicId))
{
throw new ArgumentException($"{PubSubAdapterConstants.TOPIC_ID} property not set");
}
if (!config.Properties.TryGetValue(PubSubAdapterConstants.DEPLOYMENT_ID, out _deploymentId))
{
throw new ArgumentException($"{PubSubAdapterConstants.DEPLOYMENT_ID} property not set");
}
_logger = logger;
config.Properties.TryGetValue(PubSubAdapterConstants.CUSTOM_ENDPOINT, out _customEndpoint);
string deadlineStr;
if (config.Properties.TryGetValue(PubSubAdapterConstants.DEADLINE, out deadlineStr))
{
int seconds;
if (!int.TryParse(deadlineStr, out seconds))
{
throw new ArgumentException(
$"Failed to parse {PubSubAdapterConstants.DEADLINE} value '{deadlineStr}' as a TimeSpan");
}
_deadline = TimeSpan.FromSeconds(seconds);
if (_deadline == TimeSpan.MinValue || _deadline > PubSubAdapterConstants.MAX_DEADLINE)
{
_deadline = PubSubAdapterConstants.MAX_DEADLINE;
}
}
else
{
_deadline = null;
}
_cacheSize = SimpleQueueAdapterCache.ParseSize(config, PubSubAdapterConstants.CACHE_SIZE_DEFAULT);
string numSubscriptionsString;
_numSubscriptions = PubSubAdapterConstants.NUMBER_SUBSCRIPTIONS_DEFAULT;
if (config.Properties.TryGetValue(PubSubAdapterConstants.NUMBER_SUBSCRIPTIONS, out numSubscriptionsString))
{
if (!int.TryParse(numSubscriptionsString, out _numSubscriptions))
{
throw new ArgumentException($"{PubSubAdapterConstants.NUMBER_SUBSCRIPTIONS} invalid. Must be int");
}
}
_providerName = providerName;
_streamQueueMapper = new HashRingBasedStreamQueueMapper(_numSubscriptions, providerName);
_adapterCache = new SimpleQueueAdapterCache(_cacheSize, logger);
if (StreamFailureHandlerFactory == null)
{
StreamFailureHandlerFactory =
qid => Task.FromResult <IStreamFailureHandler>(new NoOpStreamDeliveryFailureHandler());
}
SerializationManager = serviceProvider.GetRequiredService <SerializationManager>();
_adaptorFactory = () => ActivatorUtilities.GetServiceOrCreateInstance <TDataAdapter>(serviceProvider);
}
public async Task Init(string name, IProviderRuntime providerUtilitiesManager, IProviderConfiguration config)
{
if (String.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name");
}
if (providerUtilitiesManager == null)
{
throw new ArgumentNullException("providerUtilitiesManager");
}
if (config == null)
{
throw new ArgumentNullException("config");
}
Name = name;
providerRuntime = (IStreamProviderRuntime)providerUtilitiesManager;
logger = providerRuntime.GetLogger(this.GetType().Name);
adapterFactory = new TAdapterFactory();
adapterFactory.Init(config, Name, logger);
queueAdapter = await adapterFactory.CreateAdapter();
string timePeriod;
if (!config.Properties.TryGetValue(GET_QUEUE_MESSAGES_TIMER_PERIOD, out timePeriod))
{
getQueueMsgsTimerPeriod = DEFAULT_GET_QUEUE_MESSAGES_TIMER_PERIOD;
}
else
{
getQueueMsgsTimerPeriod = ConfigUtilities.ParseTimeSpan(timePeriod,
"Invalid time value for the " + GET_QUEUE_MESSAGES_TIMER_PERIOD + " property in the provider config values.");
}
string timeout;
if (!config.Properties.TryGetValue(INIT_QUEUE_TIMEOUT, out timeout))
{
initQueueTimeout = DEFAULT_INIT_QUEUE_TIMEOUT;
}
else
{
initQueueTimeout = ConfigUtilities.ParseTimeSpan(timeout,
"Invalid time value for the " + INIT_QUEUE_TIMEOUT + " property in the provider config values.");
}
string balanceTypeString;
balancerType = !config.Properties.TryGetValue(QUEUE_BALANCER_TYPE, out balanceTypeString)
? DEFAULT_STREAM_QUEUE_BALANCER_TYPE
: (StreamQueueBalancerType)Enum.Parse(typeof(StreamQueueBalancerType), balanceTypeString);
if (!config.Properties.TryGetValue(MAX_EVENT_DELIVERY_TIME, out timeout))
{
maxEventDeliveryTime = DEFAULT_MAX_EVENT_DELIVERY_TIME;
}
else
{
maxEventDeliveryTime = ConfigUtilities.ParseTimeSpan(timeout,
"Invalid time value for the " + MAX_EVENT_DELIVERY_TIME + " property in the provider config values.");
}
logger.Info("Initialized PersistentStreamProvider<{0}> with name {1}, {2} = {3}, {4} = {5} and with Adapter {6}.",
typeof(TAdapterFactory).Name, Name,
GET_QUEUE_MESSAGES_TIMER_PERIOD, getQueueMsgsTimerPeriod,
INIT_QUEUE_TIMEOUT, this.initQueueTimeout,
queueAdapter.Name);
}
/// <summary>
/// Construtor padrão.
/// </summary>
/// <param name="providerConfiguration">Provider de configuração usado na analise.</param>
public DatabaseAnalyzer(IProviderConfiguration providerConfiguration)
{
this.providerConfiguration = providerConfiguration;
tablesMaps = new Hashtable();
}
/// <inheritdoc/>
public override Task Initialize(string strProviderName, IStreamQueueMapper queueMapper, TimeSpan siloMaturityPeriod, IProviderConfiguration providerConfig)
{
if (queueMapper == null)
{
throw new ArgumentNullException("queueMapper");
}
var balancerConfig = new LeaseBasedQueueBalancerConfig(providerConfig);
this.leaseProvider = this.serviceProvider.GetRequiredService(balancerConfig.LeaseProviderType) as ILeaseProvider;
this.leaseLength = balancerConfig.LeaseLength;
this.allQueues = new ReadOnlyCollection <QueueId>(queueMapper.GetAllQueues().ToList());
this.siloMaturityPeriod = siloMaturityPeriod;
NotifyAfterStart().Ignore();
//make lease renew frequency to be every half of lease time, to avoid renew failing due to timing issues, race condition or clock difference.
var timerLogger = this.loggerFactory.CreateLogger <AsyncTaskSafeTimer>();
this.renewLeaseTimer = new AsyncTaskSafeTimer(timerLogger, this.MaintainAndBalanceQueues, null, this.siloMaturityPeriod, this.leaseLength.Divide(2));
//try to acquire maximum leases every leaseLength
this.tryAcquireMaximumLeaseTimer = new AsyncTaskSafeTimer(timerLogger, this.AcquireLeaseToMeetMaxResponsibilty, null, this.siloMaturityPeriod, this.leaseLength);
//Selector default to round robin selector now, but we can make a further change to make selector configurable if needed. Selector algorithm could
//be affecting queue balancing stablization time in cluster initializing and auto-scaling
this.queueSelector = new RoundRobinSelector <QueueId>(this.allQueues);
return(MaintainAndBalanceQueues(null));
}
/// <summary>
/// Customises the given serializer settings using provider configuration.
/// Can be used by any provider, allowing the users to use a standard set of configuration attributes.
/// </summary>
/// <param name="settings">The settings to update.</param>
/// <param name="config">The provider config.</param>
/// <returns>The updated <see cref="JsonSerializerSettings" />.</returns>
public static JsonSerializerSettings UpdateSerializerSettings(JsonSerializerSettings settings, IProviderConfiguration config)
{
if (config.Properties.ContainsKey(UseFullAssemblyNamesProperty))
{
bool useFullAssemblyNames;
if (bool.TryParse(config.Properties[UseFullAssemblyNamesProperty], out useFullAssemblyNames) && useFullAssemblyNames)
{
settings.TypeNameAssemblyFormatHandling = TypeNameAssemblyFormatHandling.Full;
}
}
if (config.Properties.ContainsKey(IndentJsonProperty))
{
bool indentJson;
if (bool.TryParse(config.Properties[IndentJsonProperty], out indentJson) && indentJson)
{
settings.Formatting = Formatting.Indented;
}
}
if (config.Properties.ContainsKey(TypeNameHandlingProperty))
{
TypeNameHandling typeNameHandling;
if (Enum.TryParse <TypeNameHandling>(config.Properties[TypeNameHandlingProperty], out typeNameHandling))
{
settings.TypeNameHandling = typeNameHandling;
}
}
return(settings);
}
public async override Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
Log = providerRuntime.GetLogger(this.GetType().FullName);
Log.Info(0, "Init ErrorInjection={0}", ErrorInjection);
try
{
SetErrorInjection(ErrorInjectionPoint.None);
await base.Init(name, providerRuntime, config);
}
catch (Exception exc)
{
Log.Error(0, "Unexpected error during Init", exc);
throw;
}
}
public PersistentStreamProviderConfig(IProviderConfiguration config)
{
string timePeriod;
if (!config.Properties.TryGetValue(GET_QUEUE_MESSAGES_TIMER_PERIOD, out timePeriod))
{
GetQueueMsgsTimerPeriod = DEFAULT_GET_QUEUE_MESSAGES_TIMER_PERIOD;
}
else
{
GetQueueMsgsTimerPeriod = ConfigUtilities.ParseTimeSpan(timePeriod,
"Invalid time value for the " + GET_QUEUE_MESSAGES_TIMER_PERIOD + " property in the provider config values.");
}
string timeout;
if (!config.Properties.TryGetValue(INIT_QUEUE_TIMEOUT, out timeout))
{
InitQueueTimeout = DEFAULT_INIT_QUEUE_TIMEOUT;
}
else
{
InitQueueTimeout = ConfigUtilities.ParseTimeSpan(timeout,
"Invalid time value for the " + INIT_QUEUE_TIMEOUT + " property in the provider config values.");
}
string balanceTypeString;
BalancerType = !config.Properties.TryGetValue(QUEUE_BALANCER_TYPE, out balanceTypeString)
? DEFAULT_STREAM_QUEUE_BALANCER_TYPE
: (StreamQueueBalancerType)Enum.Parse(typeof(StreamQueueBalancerType), balanceTypeString);
if (!config.Properties.TryGetValue(MAX_EVENT_DELIVERY_TIME, out timeout))
{
MaxEventDeliveryTime = DEFAULT_MAX_EVENT_DELIVERY_TIME;
}
else
{
MaxEventDeliveryTime = ConfigUtilities.ParseTimeSpan(timeout,
"Invalid time value for the " + MAX_EVENT_DELIVERY_TIME + " property in the provider config values.");
}
if (!config.Properties.TryGetValue(STREAM_INACTIVITY_PERIOD, out timeout))
{
StreamInactivityPeriod = DEFAULT_STREAM_INACTIVITY_PERIOD;
}
else
{
StreamInactivityPeriod = ConfigUtilities.ParseTimeSpan(timeout,
"Invalid time value for the " + STREAM_INACTIVITY_PERIOD + " property in the provider config values.");
}
string pubSubTypeString;
PubSubType = !config.Properties.TryGetValue(STREAM_PUBSUB_TYPE, out pubSubTypeString)
? DEFAULT_STREAM_PUBSUB_TYPE
: (StreamPubSubType)Enum.Parse(typeof(StreamPubSubType), pubSubTypeString);
string immaturityPeriod;
if (!config.Properties.TryGetValue(SILO_MATURITY_PERIOD, out immaturityPeriod))
{
SiloMaturityPeriod = DEFAULT_SILO_MATURITY_PERIOD;
}
else
{
SiloMaturityPeriod = ConfigUtilities.ParseTimeSpan(immaturityPeriod,
"Invalid time value for the " + SILO_MATURITY_PERIOD + " property in the provider config values.");
}
}
public async Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
Name = name;
await GetLocalHub().Init();
}
public async override Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config)
{
this.logger = providerRuntime.ServiceProvider.GetRequiredService <ILogger <ErrorInjectionStorageProvider> >();
logger.Info(0, "Init ErrorInjection={0}", ErrorInjection);
try
{
SetErrorInjection(ErrorInjectionBehavior.None);
await base.Init(name, providerRuntime, config);
}
catch (Exception exc)
{
logger.Error(0, "Unexpected error during Init", exc);
throw;
}
}
/// <summary>
/// Populate data generating config from provider config
/// </summary>
/// <param name="providerConfiguration"></param>
public void PopulateDataGeneratingConfigFromProviderConfig(IProviderConfiguration providerConfiguration)
{
this.streamDataGeneratorType = providerConfiguration.GetTypeProperty(StreamDataGeneratorTypeName, DefaultStreamDataGeneratorType);
this.EventHubPartitionCount = providerConfiguration.GetIntProperty(EventHubPartitionCountName, DefaultEventHubPartitionCount);
}
// used only for testing
internal async Task AddAndInitProvider(string name, IStorageProvider provider, IProviderConfiguration config = null)
{
await provider.Init(name, this, config);
storageProviderLoader.AddProvider(name, provider, config);
}
public override void Init(IProviderConfiguration providerCfg, string providerName, Logger log, IServiceProvider svcProvider)
{
this.ReceiverMonitorFactory = (dimensions, logger) => EventHubReceiverMonitorForTesting.Instance;
this.cachePressureInjectionMonitor = new CachePressureInjectionMonitor();
base.Init(providerCfg, providerName, log, svcProvider);
}
/// <summary>
/// Populate data generating config from provider config
/// </summary>
/// <param name="providerConfiguration"></param>
public void PopulateDataGeneratingConfigFromProviderConfig(IProviderConfiguration providerConfiguration)
{
this.streamDataGeneratorType = providerConfiguration.GetTypeProperty(StreamDataGeneratorTypeName, DefaultStreamDataGeneratorType);
}
