public AzureBasedReminderTable(IGrainReferenceConverter grainReferenceConverter, ILoggerFactory loggerFactory, IOptions <SiloOptions> siloOptions)
{
this.grainReferenceConverter = grainReferenceConverter;
this.logger = loggerFactory.CreateLogger <AzureBasedReminderTable>();
this.loggerFactory = loggerFactory;
this.siloOptions = siloOptions.Value;
}
public ProtocolServices(
Grain gr,
ILoggerFactory loggerFactory,
IMultiClusterRegistrationStrategy strategy,
SerializationManager serializationManager,
IInternalGrainFactory grainFactory,
IOptions <SiloOptions> siloOptions,
IOptions <MultiClusterOptions> multiClusterOptions,
IMultiClusterOracle multiClusterOracle)
{
this.grain = gr;
this.log = loggerFactory.CreateLogger <ProtocolServices>();
this.grainFactory = grainFactory;
this.RegistrationStrategy = strategy;
this.SerializationManager = serializationManager;
this.multiClusterOracle = multiClusterOracle;
this.siloOptions = siloOptions.Value;
this.multiClusterOptions = multiClusterOptions.Value;
if (!this.multiClusterOptions.HasMultiClusterNetwork)
{
// we are creating a default multi-cluster configuration containing exactly one cluster, this one.
this.pseudoMultiClusterConfiguration = PseudoMultiClusterConfigurations.FindOrCreate(
this.siloOptions.ClusterId,
CreatePseudoConfig);
}
}
public KubeMembershipTable(ILoggerFactory loggerFactory, IOptions <SiloOptions> siloOptions, IOptions <KubeClusteringOptions> clusteringOptions)
{
this._siloOptions = siloOptions.Value;
this._loggerFactory = loggerFactory;
this._logger = loggerFactory?.CreateLogger <KubeMembershipTable>();
this._options = clusteringOptions.Value;
}
public MultiClusterGossipChannelFactory(IOptions <SiloOptions> siloOptions, IOptions <MultiClusterOptions> multiClusterOptions, IServiceProvider serviceProvider, ILogger <MultiClusterGossipChannelFactory> logger)
{
this.siloOptions = siloOptions.Value;
this.multiClusterOptions = multiClusterOptions.Value;
this.serviceProvider = serviceProvider;
this.logger = logger;
}
public SQSAdapterFactory(string name, SqsStreamOptions options, IServiceProvider serviceProvider, IOptions <SiloOptions> siloOptions, SerializationManager serializationManager, ILoggerFactory loggerFactory)
{
this.providerName = name;
this.options = options;
this.siloOptions = siloOptions.Value;
this.serializationManager = serializationManager;
this.loggerFactory = loggerFactory;
}
public PubSubAdapterFactory(string name, PubSubStreamOptions options, IServiceProvider serviceProvider, IOptions <SiloOptions> siloOptions, SerializationManager serializationManager, ILoggerFactory loggerFactory)
{
this._providerName = name;
this.options = options;
this.siloOptions = siloOptions.Value;
this.SerializationManager = serializationManager;
this.loggerFactory = loggerFactory;
this._adaptorFactory = () => ActivatorUtilities.GetServiceOrCreateInstance <TDataAdapter>(serviceProvider);
}
public AzureQueueAdapterFactory(string name, AzureQueueStreamOptions options, IServiceProvider serviceProvider, IOptions <SiloOptions> siloOptions, SerializationManager serializationManager, ILoggerFactory loggerFactory)
{
this.providerName = name;
this.options = options ?? throw new ArgumentNullException(nameof(options));
this.siloOptions = siloOptions.Value;
this.SerializationManager = serializationManager ?? throw new ArgumentNullException(nameof(serializationManager));
this.loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
this.dataAadaptorFactory = () => ActivatorUtilities.GetServiceOrCreateInstance <TDataAdapter>(serviceProvider);
}
public CosmosDBReminderTable(IGrainReferenceConverter grainReferenceConverter,
ILoggerFactory loggerFactory,
IOptions <SiloOptions> siloOptions,
IOptions <AzureCosmosDBReminderProviderOptions> options)
{
this._loggerFactory = loggerFactory;
this._logger = loggerFactory.CreateLogger(nameof(CosmosDBReminderTable));
this._siloOptions = siloOptions.Value;
this._options = options.Value;
this._grainReferenceConverter = grainReferenceConverter;
}
internal GatewayAcceptor(
MessageCenter msgCtr,
Gateway gateway,
IPEndPoint gatewayAddress,
MessageFactory messageFactory,
SerializationManager serializationManager,
ExecutorService executorService,
IOptions <SiloOptions> siloOptions,
IOptions <MultiClusterOptions> multiClusterOptions,
ILoggerFactory loggerFactory)
: base(msgCtr, gatewayAddress, SocketDirection.GatewayToClient, messageFactory, serializationManager, executorService, loggerFactory)
{
this.gateway = gateway;
this.loadSheddingCounter = CounterStatistic.FindOrCreate(StatisticNames.GATEWAY_LOAD_SHEDDING);
this.gatewayTrafficCounter = CounterStatistic.FindOrCreate(StatisticNames.GATEWAY_RECEIVED);
this.siloOptions = siloOptions.Value;
this.multiClusterOptions = multiClusterOptions.Value;
}
public GlobalSingleInstanceActivationMaintainer(
LocalGrainDirectory router,
Logger logger,
GlobalConfiguration config,
IInternalGrainFactory grainFactory,
IMultiClusterOracle multiClusterOracle,
ExecutorService executorService,
IOptions <SiloOptions> siloOptions,
IOptions <MultiClusterOptions> multiClusterOptions,
ILoggerFactory loggerFactory)
: base(executorService, loggerFactory)
{
this.router = router;
this.logger = logger;
this.grainFactory = grainFactory;
this.multiClusterOracle = multiClusterOracle;
this.siloOptions = siloOptions.Value;
this.multiClusterOptions = multiClusterOptions.Value;
this.period = config.GlobalSingleInstanceRetryInterval;
logger.Verbose("GSIP:M GlobalSingleInstanceActivationMaintainer Started, Period = {0}", period);
}
public SiloStatisticsManager(SiloInitializationParameters initializationParams, SerializationManager serializationManager, ITelemetryProducer telemetryProducer, ILoggerFactory loggerFactory, IOptions <SiloOptions> siloOptions)
{
MessagingStatisticsGroup.Init(true);
MessagingProcessingStatisticsGroup.Init();
NetworkingStatisticsGroup.Init(true);
ApplicationRequestsStatisticsGroup.Init(initializationParams.ClusterConfig.Globals.ResponseTimeout);
SchedulerStatisticsGroup.Init(loggerFactory);
StorageStatisticsGroup.Init();
TransactionsStatisticsGroup.Init();
this.logger = new LoggerWrapper <SiloStatisticsManager>(loggerFactory);
runtimeStats = new RuntimeStatisticsGroup(loggerFactory);
this.logStatistics = new LogStatistics(initializationParams.NodeConfig.StatisticsLogWriteInterval, true, serializationManager, loggerFactory);
this.MetricsTable = new SiloPerformanceMetrics(this.runtimeStats, loggerFactory, initializationParams.NodeConfig);
this.countersPublisher = new CountersStatistics(initializationParams.NodeConfig.StatisticsPerfCountersWriteInterval, telemetryProducer, loggerFactory);
initializationParams.ClusterConfig.OnConfigChange(
"Defaults/LoadShedding",
() => this.MetricsTable.NodeConfig = initializationParams.NodeConfig,
false);
this.siloOptions = siloOptions.Value;
}
/// <summary>
/// Returns a correct implementation of the persistence provider according to environment variables.
/// </summary>
/// <remarks>If the environment invariants have failed to hold upon creation of the storage provider,
/// a <em>null</em> value will be provided.</remarks>
public async Task <IGrainStorage> GetStorageProvider(string storageInvariant)
{
//Make sure the environment invariants hold before trying to give a functioning SUT instantiation.
//This is done instead of the constructor to have more granularity on how the environment should be initialized.
try
{
using (await StorageLock.LockAsync())
{
if (AdoNetInvariants.Invariants.Contains(storageInvariant))
{
if (!StorageProviders.ContainsKey(storageInvariant))
{
Storage = Invariants.EnsureStorageForTesting(Invariants.ActiveSettings.ConnectionStrings.First(i => i.StorageInvariant == storageInvariant));
var options = new AdoNetGrainStorageOptions()
{
ConnectionString = Storage.Storage.ConnectionString,
Invariant = storageInvariant
};
var siloOptions = new SiloOptions()
{
ServiceId = Guid.NewGuid()
};
var storageProvider = new AdoNetGrainStorage(DefaultProviderRuntime.ServiceProvider.GetService <ILogger <AdoNetGrainStorage> >(), DefaultProviderRuntime, Options.Create(options), Options.Create(siloOptions), storageInvariant + "_StorageProvider");
var siloLifeCycle = new SiloLifecycle(NullLoggerFactory.Instance);
storageProvider.Participate(siloLifeCycle);
await siloLifeCycle.OnStart(CancellationToken.None);
StorageProviders[storageInvariant] = storageProvider;
}
}
}
}
catch
{
StorageProviders.Add(storageInvariant, null);
}
return(StorageProviders[storageInvariant]);
}
public void Configure(SiloOptions options)
{
options.SiloName = Environment.GetEnvironmentVariable(KubernetesHostingOptions.PodNameEnvironmentVariable);
}
