public SiloProviderRuntime(
ILocalSiloDetails siloDetails,
IOptions <SiloOptions> siloOptions,
IConsistentRingProvider consistentRingProvider,
ISiloRuntimeClient runtimeClient,
ImplicitStreamSubscriberTable implicitStreamSubscriberTable,
ISiloStatusOracle siloStatusOracle,
OrleansTaskScheduler scheduler,
ActivationDirectory activationDirectory,
ILoggerFactory loggerFactory)
{
this.loggerFactory = loggerFactory;
this.siloStatusOracle = siloStatusOracle;
this.scheduler = scheduler;
this.activationDirectory = activationDirectory;
this.consistentRingProvider = consistentRingProvider;
this.runtimeClient = runtimeClient;
this.ServiceId = siloOptions.Value.ServiceId;
this.SiloIdentity = siloDetails.SiloAddress.ToLongString();
this.grainBasedPubSub = new GrainBasedPubSubRuntime(this.GrainFactory);
var tmp = new ImplicitStreamPubSub(this.runtimeClient.InternalGrainFactory, implicitStreamSubscriberTable);
this.implictPubSub = tmp;
this.combinedGrainBasedAndImplicitPubSub = new StreamPubSubImpl(this.grainBasedPubSub, tmp);
}
public OrleansStreamingPubSub(IGrainFactory grainFactory, ILocalSiloDetails silo, ILogger <OrleansStreamingPubSub> logger)
{
hostGrain =
grainFactory.GetGrain <IStreamingPubSubHostGrain>(
silo.SiloAddress.ToParsableString());
subscriptions = new Subscriptions(logger);
}
/// <summary>
/// This should be primary constructor once IAsyncEnumerable is released
/// </summary>
private QueueBalancerBase(IClusterMembershipService clusterMembership, ILocalSiloDetails localSiloDetails, ILogger logger)
{
this.clusterMembershipUpdates = clusterMembership.MembershipUpdates;
this.SiloAddress = localSiloDetails.SiloAddress;
this.Logger = logger;
this.queueBalanceListeners = new List <IStreamQueueBalanceListener>();
this.cts = new CancellationTokenSource();
}
public DashboardTelemetryConsumer(ILocalSiloDetails localSiloDetails, IGrainFactory grainFactory)
{
this.localSiloDetails = localSiloDetails;
this.grainFactory = grainFactory;
// register timer to report every second
timer = new Timer(x => Flush(), null, 1 * 1000, 1 * 1000);
}
public OrleansPubSub(IGrainFactory grainFactory, ILocalSiloDetails localSiloDetails, ILogger <OrleansPubSub> logger)
{
brokerGrain = grainFactory.GetGrain <IPubSubBrokerGrain>(Constants.BrokerId);
hostGrain = grainFactory.GetGrain <IPubSubHostGrain>(localSiloDetails.SiloAddress.ToParsableString());
this.logger = logger;
}
public GrainProfiler(IGrainFactory grainFactory, ILogger <GrainProfiler> logger, ILocalSiloDetails localSiloDetails, IGrainServiceDataBack serviceback)
{
this.grainFactory = grainFactory;
this.logger = logger;
this.localSiloDetails = localSiloDetails;
grainseerviceDataBack = serviceback;
}
public ClusterManifestSystemTarget(
IClusterManifestProvider clusterManifestProvider,
ILocalSiloDetails siloDetails,
ILoggerFactory loggerFactory)
: base(Constants.ManifestProviderType, siloDetails.SiloAddress, loggerFactory)
{
_siloManifest = clusterManifestProvider.LocalGrainManifest;
_clusterManifestProvider = clusterManifestProvider;
}
public DashboardTelemetryProducer(ILocalSiloDetails localSiloDetails, IGrainFactory grainFactory, IExternalDispatcher dispatcher)
{
this.localSiloDetails = localSiloDetails;
this.grainFactory = grainFactory;
this.dispatcher = dispatcher;
// register timer to report every second
timer = new Timer(x => Flush(), null, 1 * 1000, 1 * 1000);
}
public MembershipTableSystemTarget(
ILocalSiloDetails localSiloDetails,
ILoggerFactory loggerFactory,
SerializationManager serializationManager)
: base(CreateId(localSiloDetails), localSiloDetails.SiloAddress, lowPriority: false, loggerFactory)
{
logger = loggerFactory.CreateLogger <MembershipTableSystemTarget>();
table = new InMemoryMembershipTable(serializationManager);
logger.Info(ErrorCode.MembershipGrainBasedTable1, "GrainBasedMembershipTable Activated.");
}
public GrainProfiler(IGrainFactory grainFactory, ILogger <GrainProfiler> logger, ILocalSiloDetails localSiloDetails)
{
this.grainFactory = grainFactory;
this.logger = logger;
this.localSiloDetails = localSiloDetails;
// register timer to report every second
timer = new Timer(ProcessStats, null, 1 * 1000, 1 * 1000);
}
public MembershipTableSystemTarget(
ILocalSiloDetails localSiloDetails,
ILoggerFactory loggerFactory,
DeepCopier deepCopier)
: base(CreateId(localSiloDetails), localSiloDetails.SiloAddress, lowPriority: false, loggerFactory)
{
logger = loggerFactory.CreateLogger <MembershipTableSystemTarget>();
table = new InMemoryMembershipTable(deepCopier);
logger.LogInformation((int)ErrorCode.MembershipGrainBasedTable1, "GrainBasedMembershipTable Activated.");
}
public SiloStatusOracle(
ILocalSiloDetails localSiloDetails,
MembershipTableManager membershipTableManager,
ILogger <SiloStatusOracle> logger,
SiloStatusListenerManager listenerManager)
{
this.localSiloDetails = localSiloDetails;
this.membershipTableManager = membershipTableManager;
this.listenerManager = listenerManager;
this.log = logger;
}
internal RemoteGrainDirectory(
ILocalSiloDetails localSiloDetails,
LocalGrainDirectory localGrainDirectory,
GrainId id,
ILoggerFactory loggerFactory)
: base(id, localSiloDetails.SiloAddress, loggerFactory)
{
this.localGrainDirectory = localGrainDirectory;
partition = localGrainDirectory.DirectoryPartition;
logger = loggerFactory.CreateLogger($"{typeof(RemoteGrainDirectory).FullName}.CacheValidator");
}
public Dashboard(
ILogger <Dashboard> logger,
ILocalSiloDetails localSiloDetails,
IGrainFactory grainFactory,
IOptions <DashboardOptions> dashboardOptions)
{
this.logger = logger;
this.grainFactory = grainFactory;
this.localSiloDetails = localSiloDetails;
this.dashboardOptions = dashboardOptions.Value;
}
public SiloStatusOracle(
ILocalSiloDetails localSiloDetails,
MembershipTableManager membershipTableManager,
ILoggerFactory loggerFactory,
SiloStatusListenerManager listenerManager)
{
this.localSiloDetails = localSiloDetails;
this.membershipTableManager = membershipTableManager;
this.listenerManager = listenerManager;
this.log = loggerFactory.CreateLogger("MembershipOracle");
}
private readonly Grain grain; // links to the grain that owns this service object
public ProtocolServices(
Grain gr,
ILoggerFactory loggerFactory,
DeepCopier deepCopier,
ILocalSiloDetails siloDetails)
{
this.grain = gr;
this.log = loggerFactory.CreateLogger <ProtocolServices>();
this.deepCopier = deepCopier;
this.MyClusterId = siloDetails.ClusterId;
}
public HubListUpdater(
IGrainFactory grainFactory,
ILogger <HubListUpdater> logger,
ILocalSiloDetails localSiloDetails,
IHubContext <LocationHub> hubContext)
{
_grainFactory = grainFactory;
_logger = logger;
_localSiloDetails = localSiloDetails;
_locationBroadcaster = new RemoteLocationHub(hubContext);
}
public GrainVersionStore(
IInternalGrainFactory grainFactory,
ILocalSiloDetails siloDetails,
IServiceProvider services,
ISiloLifecycle siloLifecycle)
{
this.grainFactory = grainFactory;
this.services = services;
this.siloLifecycle = siloLifecycle;
this.clusterId = siloDetails.ClusterId;
this.hasGrainStorage = this.services.GetService <IGrainStorage>() != null;
}
public MembershipSystemTarget(
MembershipTableManager membershipTableManager,
ILocalSiloDetails localSiloDetails,
ILoggerFactory loggerFactory,
ILogger <MembershipSystemTarget> log,
IInternalGrainFactory grainFactory)
: base(Constants.MembershipServiceType, localSiloDetails.SiloAddress, loggerFactory)
{
this.membershipTableManager = membershipTableManager;
this.log = log;
this.grainFactory = grainFactory;
}
public GrainTypeManager(ILocalSiloDetails siloDetails, SiloAssemblyLoader loader, DefaultPlacementStrategy defaultPlacementStrategy, SerializationManager serializationManager, MultiClusterRegistrationStrategyManager multiClusterRegistrationStrategyManager)
{
var localTestMode = siloDetails.SiloAddress.Endpoint.Address.Equals(IPAddress.Loopback);
this.defaultPlacementStrategy = defaultPlacementStrategy.PlacementStrategy;
this.loader = loader;
this.serializationManager = serializationManager;
this.multiClusterRegistrationStrategyManager = multiClusterRegistrationStrategyManager;
grainInterfaceMap = new GrainInterfaceMap(localTestMode, this.defaultPlacementStrategy);
ClusterGrainInterfaceMap = grainInterfaceMap;
grainInterfaceMapsBySilo = new Dictionary <SiloAddress, GrainInterfaceMap>();
}
/// <summary>
/// Initializes a new instance of the <see cref="FabricMembershipOracle"/> class.
/// </summary>
/// <param name="localSiloDetails">The silo which this instance will provide membership information for.</param>
/// <param name="globalConfig">The cluster configuration.</param>
/// <param name="fabricServiceSiloResolver">The service resolver which this instance will use.</param>
/// <param name="logger">The logger.</param>
public FabricMembershipOracle(
ILocalSiloDetails localSiloDetails,
GlobalConfiguration globalConfig,
IFabricServiceSiloResolver fabricServiceSiloResolver,
ILogger <FabricMembershipOracle> logger)
{
this.log = logger;
this.localSiloDetails = localSiloDetails;
this.globalConfig = globalConfig;
this.fabricServiceSiloResolver = fabricServiceSiloResolver;
this.silos[this.SiloAddress] = new SiloEntry(SiloStatus.Created, this.SiloName);
}
public Catalog(
ILocalSiloDetails localSiloDetails,
GrainLocator grainLocator,
GrainDirectoryResolver grainDirectoryResolver,
ILocalGrainDirectory grainDirectory,
ActivationDirectory activationDirectory,
ActivationCollector activationCollector,
IServiceProvider serviceProvider,
ILoggerFactory loggerFactory,
IOptions <GrainCollectionOptions> collectionOptions,
RuntimeMessagingTrace messagingTrace,
GrainContextActivator grainActivator,
GrainPropertiesResolver grainPropertiesResolver)
: base(Constants.CatalogType, localSiloDetails.SiloAddress, loggerFactory)
{
this.LocalSilo = localSiloDetails.SiloAddress;
this.localSiloName = localSiloDetails.Name;
this.grainLocator = grainLocator;
this.grainDirectoryResolver = grainDirectoryResolver;
this.directory = grainDirectory;
this.activations = activationDirectory;
this.serviceProvider = serviceProvider;
this.collectionOptions = collectionOptions;
this.grainActivator = grainActivator;
this.grainPropertiesResolver = grainPropertiesResolver;
this.logger = loggerFactory.CreateLogger <Catalog>();
this.activationCollector = activationCollector;
this.RuntimeClient = serviceProvider.GetRequiredService <InsideRuntimeClient>();
GC.GetTotalMemory(true); // need to call once w/true to ensure false returns OK value
IntValueStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_COUNT, () => activations.Count);
activationsCreated = CounterStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_CREATED);
activationsDestroyed = CounterStatistic.FindOrCreate(StatisticNames.CATALOG_ACTIVATION_DESTROYED);
IntValueStatistic.FindOrCreate(StatisticNames.MESSAGING_PROCESSING_ACTIVATION_DATA_ALL, () =>
{
long counter = 0;
lock (activations)
{
foreach (var activation in activations)
{
if (activation.Value is ActivationData data)
{
counter += data.GetRequestCount();
}
}
}
return(counter);
});
grainDirectory.SetSiloRemovedCatalogCallback(this.OnSiloStatusChange);
RegisterSystemTarget(this);
}
public SiloConnectionFactory(
IServiceProvider serviceProvider,
IOptions <ConnectionOptions> connectionOptions,
IOptions <SiloConnectionOptions> siloConnectionOptions,
ILocalSiloDetails localSiloDetails,
ConnectionCommon connectionShared)
: base(serviceProvider.GetRequiredServiceByKey <object, IConnectionFactory>(ServicesKey), serviceProvider, connectionOptions)
{
this.serviceProvider = serviceProvider;
this.siloConnectionOptions = siloConnectionOptions.Value;
this.localSiloDetails = localSiloDetails;
this.connectionShared = connectionShared;
}
public MembershipTableManagerTests(ITestOutputHelper output)
{
this.output = output;
this.loggerFactory = new LoggerFactory(new[] { new XunitLoggerProvider(this.output) });
this.localSiloDetails = Substitute.For <ILocalSiloDetails>();
this.localSilo = Silo("127.0.0.1:100@100");
this.localSiloDetails.SiloAddress.Returns(this.localSilo);
this.localSiloDetails.DnsHostName.Returns("MyServer11");
this.localSiloDetails.Name.Returns(Guid.NewGuid().ToString("N"));
this.fatalErrorHandler = Substitute.For <IFatalErrorHandler>();
this.fatalErrorHandler.IsUnexpected(default).ReturnsForAnyArgs(true);
public ClientObserverRegistrar(
ILocalSiloDetails siloDetails,
ILocalGrainDirectory dir,
OrleansTaskScheduler scheduler,
ClusterConfiguration config)
: base(Constants.ClientObserverRegistrarId, siloDetails.SiloAddress)
{
grainDirectory = dir;
myAddress = siloDetails.SiloAddress;
this.scheduler = scheduler;
orleansConfig = config;
logger = LogManager.GetLogger(typeof(ClientObserverRegistrar).Name);
}
private readonly Grain grain; // links to the grain that owns this service object
public ProtocolServices(
Grain gr,
ILoggerFactory loggerFactory,
SerializationManager serializationManager,
IGrainFactory grainFactory,
ILocalSiloDetails siloDetails)
{
this.grain = gr;
this.log = loggerFactory.CreateLogger <ProtocolServices>();
this.grainFactory = grainFactory;
this.SerializationManager = serializationManager;
this.MyClusterId = siloDetails.ClusterId;
}
public TestHooksSystemTarget(
ISiloHost host,
ILocalSiloDetails siloDetails,
ILoggerFactory loggerFactory,
TestHooksHostEnvironmentStatistics hostEnvironmentStatistics,
IOptions <LoadSheddingOptions> loadSheddingOptions)
: base(Constants.TestHooksSystemTargetId, siloDetails.SiloAddress, loggerFactory)
{
this.host = host;
this.hostEnvironmentStatistics = hostEnvironmentStatistics;
this.loadSheddingOptions = loadSheddingOptions.Value;
this.consistentRingProvider = this.host.Services.GetRequiredService <IConsistentRingProvider>();
}
public SiloConnectionFactory(
IServiceProvider serviceProvider,
IOptions <ConnectionOptions> connectionOptions,
IConnectionFactory connectionFactory,
MessageFactory messageFactory,
INetworkingTrace trace,
ILocalSiloDetails localSiloDetails)
: base(connectionFactory, serviceProvider, connectionOptions)
{
this.serviceProvider = serviceProvider;
this.messageFactory = messageFactory;
this.trace = trace;
this.localSiloDetails = localSiloDetails;
}
public ClientObserverRegistrar(
ILocalSiloDetails siloDetails,
ILocalGrainDirectory dir,
OrleansTaskScheduler scheduler,
ClusterConfiguration config,
ILoggerFactory loggerFactory)
: base(Constants.ClientObserverRegistrarId, siloDetails.SiloAddress, loggerFactory)
{
grainDirectory = dir;
myAddress = siloDetails.SiloAddress;
this.scheduler = scheduler;
orleansConfig = config;
logger = loggerFactory.CreateLogger <ClientObserverRegistrar>();
}
public ClientObserverRegistrar(
ILocalSiloDetails siloDetails,
ILocalGrainDirectory dir,
OrleansTaskScheduler scheduler,
IOptions <SiloMessagingOptions> messagingOptions,
ILoggerFactory loggerFactory)
: base(Constants.ClientObserverRegistrarId, siloDetails.SiloAddress, loggerFactory)
{
grainDirectory = dir;
myAddress = siloDetails.SiloAddress;
this.scheduler = scheduler;
this.messagingOptions = messagingOptions.Value;
logger = loggerFactory.CreateLogger <ClientObserverRegistrar>();
}
public GrainRuntime(
GlobalConfiguration globalConfig,
ILocalSiloDetails localSiloDetails,
IGrainFactory grainFactory,
ITimerRegistry timerRegistry,
IReminderRegistry reminderRegistry,
IStreamProviderManager streamProviderManager,
IServiceProvider serviceProvider,
IRuntimeClient runtimeClient)
{
this.runtimeClient = runtimeClient;
ServiceId = globalConfig.ServiceId;
SiloIdentity = localSiloDetails.SiloAddress.ToLongString();
GrainFactory = grainFactory;
TimerRegistry = timerRegistry;
ReminderRegistry = reminderRegistry;
StreamProviderManager = streamProviderManager;
ServiceProvider = serviceProvider;
}
