public ProtocolServices( Grain gr, Factory <string, Logger> logFactory, IMultiClusterRegistrationStrategy strategy, SerializationManager serializationManager, IInternalGrainFactory grainFactory, GlobalConfiguration globalConfig, IMultiClusterOracle multiClusterOracle) { this.grain = gr; this.log = logFactory("LogConsistencyProtocolServices"); this.grainFactory = grainFactory; this.RegistrationStrategy = strategy; this.SerializationManager = serializationManager; this.multiClusterOracle = multiClusterOracle; this.globalConfig = globalConfig; if (!globalConfig.HasMultiClusterNetwork) { // we are creating a default multi-cluster configuration containing exactly one cluster, this one. this.pseudoMultiClusterConfiguration = PseudoMultiClusterConfigurations.FindOrCreate( this.globalConfig.ClusterId, CreatePseudoConfig); } }
public ClusterManifestProvider( ILocalSiloDetails localSiloDetails, SiloManifest localSiloManifest, IInternalGrainFactory grainFactory, ClusterMembershipService clusterMembershipService, IFatalErrorHandler fatalErrorHandler, ILogger <ClusterManifestProvider> logger, IOptions <TypeManagementOptions> options, IServiceProvider services) { _localSiloAddress = localSiloDetails.SiloAddress; _grainFactory = grainFactory; _logger = logger; _services = services; _clusterMembershipService = clusterMembershipService; _fatalErrorHandler = fatalErrorHandler; _options = options.Value; _current = new ClusterManifest( MajorMinorVersion.Zero, ImmutableDictionary.CreateRange(new[] { new KeyValuePair <SiloAddress, SiloManifest>(localSiloDetails.SiloAddress, localSiloManifest) })); _updates = new AsyncEnumerable <ClusterManifest>( (previous, proposed) => previous.Version <= MajorMinorVersion.Zero || proposed.Version > previous.Version, _current) { OnPublished = update => Interlocked.Exchange(ref _current, update) }; }
public DeploymentLoadPublisher( ILocalSiloDetails siloDetails, ISiloStatusOracle siloStatusOracle, IOptions <DeploymentLoadPublisherOptions> options, IInternalGrainFactory grainFactory, OrleansTaskScheduler scheduler, ILoggerFactory loggerFactory, IMessageCenter messageCenter, ActivationDirectory activationDirectory, ActivationCollector activationCollector, IAppEnvironmentStatistics appEnvironmentStatistics, IHostEnvironmentStatistics hostEnvironmentStatistics, IOptions <LoadSheddingOptions> loadSheddingOptions) : base(Constants.DeploymentLoadPublisherSystemTargetId, siloDetails.SiloAddress, loggerFactory) { this.logger = loggerFactory.CreateLogger <DeploymentLoadPublisher>(); this.siloDetails = siloDetails; this.siloStatusOracle = siloStatusOracle; this.grainFactory = grainFactory; this.scheduler = scheduler; this.messageCenter = messageCenter; this.activationDirectory = activationDirectory; this.activationCollector = activationCollector; this.appEnvironmentStatistics = appEnvironmentStatistics; this.hostEnvironmentStatistics = hostEnvironmentStatistics; this.loadSheddingOptions = loadSheddingOptions; statisticsRefreshTime = options.Value.DeploymentLoadPublisherRefreshTime; periodicStats = new ConcurrentDictionary <SiloAddress, SiloRuntimeStatistics>(); siloStatisticsChangeListeners = new List <ISiloStatisticsChangeListener>(); }
public HostedClient( IRuntimeClient runtimeClient, ClientObserverRegistrar clientObserverRegistrar, ILocalSiloDetails siloDetails, ILogger <HostedClient> logger, IGrainReferenceRuntime grainReferenceRuntime, IInternalGrainFactory grainFactory, InvokableObjectManager invokableObjectManager, ISiloMessageCenter messageCenter) { this.runtimeClient = runtimeClient; this.clientObserverRegistrar = clientObserverRegistrar; this.grainReferenceRuntime = grainReferenceRuntime; this.grainFactory = grainFactory; this.invokableObjects = invokableObjectManager; this.siloMessageCenter = messageCenter; this.logger = logger; this.ClientAddress = ActivationAddress.NewActivationAddress(siloDetails.SiloAddress, GrainId.NewClientId()); // Register with the directory and message center so that we can receive messages. this.clientObserverRegistrar.SetHostedClient(this); this.clientObserverRegistrar.ClientAdded(this.ClientId); this.siloMessageCenter.SetHostedClient(this); // Start pumping messages. this.Start(); }
public GrainVersionStore(IInternalGrainFactory grainFactory, ILocalSiloDetails siloDetails, IServiceProvider services) { this.grainFactory = grainFactory; this.services = services; this.clusterId = siloDetails.ClusterId; this.IsEnabled = false; }
public bool KnowsMe; // used for optimizing pushes public SiloGossipWorker(MultiClusterOracle oracle, SiloAddress Silo, IInternalGrainFactory grainFactory) : base(oracle) { this.Cluster = null; // only local cluster this.Silo = Silo; this.grainFactory = grainFactory; }
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 MultiClusterOracle( ILocalSiloDetails siloDetails, MultiClusterGossipChannelFactory channelFactory, ISiloStatusOracle siloStatusOracle, MembershipTableManager tableManager, IInternalGrainFactory grainFactory, ILoggerFactory loggerFactory, IOptions <MultiClusterOptions> multiClusterOptions) : base(Constants.MultiClusterOracleId, siloDetails.SiloAddress, loggerFactory) { this.loggerFactory = loggerFactory; this.channelFactory = channelFactory; this.siloStatusOracle = siloStatusOracle; this.tableManager = tableManager; this.grainFactory = grainFactory; logger = loggerFactory.CreateLogger <MultiClusterOracle>(); localData = new MultiClusterOracleData(logger, grainFactory); clusterId = siloDetails.ClusterId; var multiClusterOptionsSnapshot = multiClusterOptions.Value; defaultMultiCluster = multiClusterOptionsSnapshot.DefaultMultiCluster?.ToList(); this.multiClusterActive = multiClusterOptionsSnapshot.HasMultiClusterNetwork; this.maxMultiClusterGateways = multiClusterOptionsSnapshot.MaxMultiClusterGateways; random = new SafeRandom(); // to avoid convoying, each silo varies these period intervals a little backgroundGossipInterval = RandomizeTimespanSlightly(multiClusterOptionsSnapshot.BackgroundGossipInterval); resendActiveStatusAfter = RandomizeTimespanSlightly(ResendActiveStatusAfter); }
public HostedClient( IRuntimeClient runtimeClient, ClientObserverRegistrar clientObserverRegistrar, ILocalSiloDetails siloDetails, ILogger <HostedClient> logger, IGrainReferenceRuntime grainReferenceRuntime, IInternalGrainFactory grainFactory, InvokableObjectManager invokableObjectManager, MessageCenter messageCenter, MessagingTrace messagingTrace) { this.incomingMessages = Channel.CreateUnbounded <Message>(new UnboundedChannelOptions { SingleReader = true, SingleWriter = false, AllowSynchronousContinuations = false, }); this.runtimeClient = runtimeClient; this.clientObserverRegistrar = clientObserverRegistrar; this.grainReferenceRuntime = grainReferenceRuntime; this.grainFactory = grainFactory; this.invokableObjects = invokableObjectManager; this.siloMessageCenter = messageCenter; this.messagingTrace = messagingTrace; this.logger = logger; this.ClientAddress = ActivationAddress.NewActivationAddress(siloDetails.SiloAddress, GrainId.NewClientId()); }
/// <summary> /// Merges one partition into another, assuming partitions are disjoint. /// This method is supposed to be used by handoff manager to update the partitions when the system view (set of live silos) changes. /// </summary> /// <param name="grainFactory"></param> /// <param name="other"></param> internal void Merge(IInternalGrainFactory grainFactory, GrainDirectoryPartition other) { lock (lockable) { foreach (var pair in other.partitionData) { if (partitionData.ContainsKey(pair.Key)) { if (log.IsVerbose) { log.Verbose("While merging two disjoint partitions, same grain " + pair.Key + " was found in both partitions"); } var activationsToDrop = partitionData[pair.Key].Merge(pair.Key, pair.Value); if (activationsToDrop == null) { continue; } foreach (var siloActivations in activationsToDrop) { var remoteCatalog = grainFactory.GetSystemTarget <ICatalog>(Constants.CatalogId, siloActivations.Key); remoteCatalog.DeleteActivations(siloActivations.Value).Ignore(); } } else { partitionData.Add(pair.Key, pair.Value); } } } }
public SiloGossipWorker(MultiClusterOracle oracle, string cluster, IInternalGrainFactory grainFactory) : base(oracle) { this.Cluster = cluster; this.Silo = null; this.grainFactory = grainFactory; }
public ClusterGrainDirectory(LocalGrainDirectory r, GrainId grainId, string clusterId, IInternalGrainFactory grainFactory) : base(grainId, r.MyAddress) { this.router = r; this.clusterId = clusterId; this.grainFactory = grainFactory; this.logger = r.Logger; }
public GlobalSingleInstanceRegistrar(GrainDirectoryPartition partition, Logger logger, GlobalSingleInstanceActivationMaintainer gsiActivationMaintainer, int numRetries, IInternalGrainFactory grainFactory) { this.directoryPartition = partition; this.logger = logger; this.gsiActivationMaintainer = gsiActivationMaintainer; this.numRetries = numRetries; this.grainFactory = grainFactory; }
/// <summary> /// Initializes a new instance of the <see cref="GrainCreator"/> class. /// </summary> /// <param name="services">Service provider used to create new grains</param> /// <param name="getGrainRuntime">The delegate used to get the grain runtime.</param> /// <param name="serializationManager">The serialization manager.</param> /// <param name="grainFactory"></param> public GrainCreator(IServiceProvider services, Func <IGrainRuntime> getGrainRuntime, SerializationManager serializationManager, IInternalGrainFactory grainFactory) { this.services = services; this.serializationManager = serializationManager; this.grainFactory = grainFactory; this.grainRuntime = new Lazy <IGrainRuntime>(getGrainRuntime); this.createFactory = type => ActivatorUtilities.CreateFactory(type, Type.EmptyTypes); }
public ClientProviderRuntime(IInternalGrainFactory grainFactory, IServiceProvider serviceProvider) { this.grainFactory = grainFactory; this.ServiceProvider = serviceProvider; this.runtimeClient = serviceProvider.GetService <IRuntimeClient>(); caoTable = new Dictionary <Type, Tuple <IGrainExtension, IAddressable> >(); lockable = new AsyncLock(); }
internal GlobalSingleInstanceActivationMaintainer(LocalGrainDirectory router, Logger logger, GlobalConfiguration config, IInternalGrainFactory grainFactory) { this.router = router; this.logger = logger; this.grainFactory = grainFactory; this.period = config.GlobalSingleInstanceRetryInterval; logger.Verbose("GSIP:M GlobalSingleInstanceActivationMaintainer Started, Period = {0}", period); }
internal MultipleStreamsTestRunner(IInternalGrainFactory grainFactory, string streamProvider, int testNum = 0, bool fullTest = true) { this.grainFactory = grainFactory; this.streamProviderName = streamProvider; this.logger = LogManager.GetLogger("MultipleStreamsTestRunner", LoggerType.Application); this.testNumber = testNum; this.runFullTest = fullTest; }
internal MultiClusterOracleData(ILogger log, IInternalGrainFactory grainFactory) { logger = log; this.grainFactory = grainFactory; localData = new MultiClusterData(); activeGatewaysByCluster = new Dictionary <string, List <SiloAddress> >(); confListeners = new HashSet <GrainReference>(); }
/// <summary>Gets a detailed grain report from a specified silo</summary> /// <param name="grainFactory">The grain factory.</param> /// <param name="grainId">The grain id we are requesting information from</param> /// <param name="siloHandle">The target silo that should provide this information from it's cache</param> internal static Task <DetailedGrainReport> GetDetailedGrainReport(IInternalGrainFactory grainFactory, GrainId grainId, SiloHandle siloHandle) { // Use the siloAddress here, not the gateway address, since we may be targeting a silo on which we are not // connected to the gateway var siloControl = grainFactory.GetSystemTarget <ISiloControl>(Constants.SiloControlType, siloHandle.SiloAddress); return(siloControl.GetDetailedGrainReport(grainId)); }
/// <summary> /// Create a reference to a grain that we expect to support the stream consumer extension. /// </summary> /// <param name="grainFactory">The grain factory used to get consumer references.</param> /// <param name="streamId">The stream ID to use for the grain ID construction.</param> /// <param name="streamSubscriber">The GrainBindings for the grain to create</param> /// <returns></returns> private IStreamConsumerExtension MakeConsumerReference( IInternalGrainFactory grainFactory, InternalStreamId streamId, StreamSubscriber streamSubscriber) { var grainId = streamSubscriber.GetGrainId(streamId); return(grainFactory.GetGrain <IStreamConsumerExtension>(grainId)); }
public GrainDirectoryPartition(ISiloStatusOracle siloStatusOracle, GlobalConfiguration globalConfig, IInternalGrainFactory grainFactory) { partitionData = new Dictionary <GrainId, IGrainInfo>(); lockable = new object(); log = LogManager.GetLogger("DirectoryPartition"); this.siloStatusOracle = siloStatusOracle; this.globalConfig = globalConfig; this.grainFactory = grainFactory; }
public ClientProviderRuntime( IInternalGrainFactory grainFactory, IServiceProvider serviceProvider, ClientGrainContext clientContext) { this.grainFactory = grainFactory; this.ServiceProvider = serviceProvider; this.clientContext = clientContext; }
/// <summary> /// Currently we only support a single GrainService per Silo, when multiple are supported we will request the number of GrainServices to partition per silo here. /// </summary> protected GrainServiceClient(IServiceProvider serviceProvider) { grainFactory = serviceProvider.GetRequiredService <IInternalGrainFactory>(); ringProvider = serviceProvider.GetRequiredService <IConsistentRingProvider>(); // GrainInterfaceMap only holds IGrain types, not ISystemTarget types, so resolved via Orleans.CodeGeneration. // Resolve this before merge. grainTypeCode = GrainInterfaceUtils.GetGrainClassTypeCode(typeof(TGrainService)); }
internal SingleStreamTestRunner(IInternalGrainFactory grainFactory, string streamProvider, int testNum = 0, bool fullTest = true) { this.grainFactory = grainFactory; this.streamProviderName = streamProvider; this.logger = LogManager.GetLogger("SingleStreamTestRunner", LoggerType.Application); this.testNumber = testNum; this.runFullTest = fullTest; this.random = TestConstants.random; }
public ImplicitStreamPubSub(IInternalGrainFactory grainFactory, ImplicitStreamSubscriberTable implicitPubSubTable) { if (implicitPubSubTable == null) { throw new ArgumentNullException("implicitPubSubTable"); } this.grainFactory = grainFactory; this.implicitTable = implicitPubSubTable; }
/// <summary> /// Create a reference to a grain that we expect to support the stream consumer extension. /// </summary> /// <param name="grainFactory">The grain factory used to get consumer references.</param> /// <param name="streamId">The stream ID to use for the grain ID construction.</param> /// <param name="implTypeCode">The type code of the grain interface.</param> /// <returns></returns> private IStreamConsumerExtension MakeConsumerReference(IInternalGrainFactory grainFactory, StreamId streamId, int implTypeCode) { var keyExtension = grainsWithKeyExtensions.Contains(implTypeCode) ? streamId.Namespace : null; GrainId grainId = LegacyGrainId.GetGrainId(implTypeCode, streamId.Guid, keyExtension); return(grainFactory.GetGrain <IStreamConsumerExtension>(grainId)); }
public GrainDirectoryPartition(ISiloStatusOracle siloStatusOracle, IOptions <GrainDirectoryOptions> grainDirectoryOptions, IInternalGrainFactory grainFactory, ILoggerFactory loggerFactory) { partitionData = new Dictionary <GrainId, IGrainInfo>(); lockable = new object(); log = loggerFactory.CreateLogger <GrainDirectoryPartition>(); this.siloStatusOracle = siloStatusOracle; this.grainDirectoryOptions = grainDirectoryOptions; this.grainFactory = grainFactory; this.loggerFactory = loggerFactory; }
public GrainDirectoryPartition(ISiloStatusOracle siloStatusOracle, GlobalConfiguration globalConfig, IInternalGrainFactory grainFactory, ILoggerFactory loggerFactory) { partitionData = new Dictionary <GrainId, IGrainInfo>(); lockable = new object(); log = loggerFactory.CreateLogger <GrainDirectoryPartition>(); this.siloStatusOracle = siloStatusOracle; this.globalConfig = globalConfig; this.grainFactory = grainFactory; this.loggerFactory = loggerFactory; }
/// <summary> /// Create a reference to a grain that we expect to support the stream consumer extension. /// </summary> /// <param name="grainFactory">The grain factory used to get consumer references.</param> /// <param name="streamId">The stream ID to use for the grain ID construction.</param> /// <param name="subscriber">The subscriber prototype.</param> /// <returns></returns> private IStreamConsumerExtension MakeConsumerReference( IInternalGrainFactory grainFactory, StreamId streamId, StreamSubscriber subscriber) { var keyExtension = subscriber.IncludeNamespaceInGrainId ? streamId.Namespace : null; var grainId = GrainId.Create(subscriber.GrainType, GrainIdKeyExtensions.CreateGuidKey(streamId.Guid, keyExtension)); return(grainFactory.GetGrain <IStreamConsumerExtension>(grainId)); }
internal GrainDirectoryHandoffManager(LocalGrainDirectory localDirectory, ISiloStatusOracle siloStatusOracle, IInternalGrainFactory grainFactory) { logger = LogManager.GetLogger(this.GetType().FullName); this.localDirectory = localDirectory; this.siloStatusOracle = siloStatusOracle; this.grainFactory = grainFactory; directoryPartitionsMap = new Dictionary <SiloAddress, GrainDirectoryPartition>(); silosHoldingMyPartition = new List <SiloAddress>(); lastPromise = new Dictionary <SiloAddress, Task>(); }
public MembershipFactory(IInternalGrainFactory grainFactory) { this.grainFactory = grainFactory; logger = LogManager.GetLogger("MembershipFactory", LoggerType.Runtime); }