public override async Task OnActivateAsync() { logger = base.GetLogger("MultipleImplicitSubscriptionGrain " + base.IdentityString); logger.Info("OnActivateAsync"); var streamProvider = GetStreamProvider("SMSProvider"); redStream = streamProvider.GetStream<int>(this.GetPrimaryKey(), "red"); blueStream = streamProvider.GetStream<int>(this.GetPrimaryKey(), "blue"); await redStream.SubscribeAsync( (e, t) => { logger.Info("Received a red event {0}", e); redCounter++; return TaskDone.Done; }); await blueStream.SubscribeAsync( (e, t) => { logger.Info("Received a blue event {0}", e); blueCounter++; return TaskDone.Done; }); }
public override async Task OnActivateAsync() { await base.OnActivateAsync(); string id = this.GetPrimaryKeyLong().ToString(); logger = GetLogger(String.Format("{0}-{1}", GetType().Name, id)); logger.Info("Activate."); }
internal PersistentStreamPullingAgent( GrainId id, string strProviderName, IStreamProviderRuntime runtime, IStreamPubSub streamPubSub, QueueId queueId, PersistentStreamProviderConfig config) : base(id, runtime.ExecutingSiloAddress, true) { if (runtime == null) throw new ArgumentNullException("runtime", "PersistentStreamPullingAgent: runtime reference should not be null"); if (strProviderName == null) throw new ArgumentNullException("runtime", "PersistentStreamPullingAgent: strProviderName should not be null"); QueueId = queueId; streamProviderName = strProviderName; providerRuntime = runtime; pubSub = streamPubSub; pubSubCache = new Dictionary<StreamId, StreamConsumerCollection>(); safeRandom = new SafeRandom(); this.config = config; numMessages = 0; logger = providerRuntime.GetLogger(GrainId + "-" + streamProviderName); logger.Info((int)ErrorCode.PersistentStreamPullingAgent_01, "Created {0} {1} for Stream Provider {2} on silo {3} for Queue {4}.", GetType().Name, GrainId.ToDetailedString(), streamProviderName, Silo, QueueId.ToStringWithHashCode()); string statUniquePostfix = strProviderName + "." + QueueId; numReadMessagesCounter = CounterStatistic.FindOrCreate(new StatisticName(StatisticNames.STREAMS_PERSISTENT_STREAM_NUM_READ_MESSAGES, statUniquePostfix)); numSentMessagesCounter = CounterStatistic.FindOrCreate(new StatisticName(StatisticNames.STREAMS_PERSISTENT_STREAM_NUM_SENT_MESSAGES, statUniquePostfix)); IntValueStatistic.FindOrCreate(new StatisticName(StatisticNames.STREAMS_PERSISTENT_STREAM_PUBSUB_CACHE_SIZE, statUniquePostfix), () => pubSubCache.Count); // TODO: move queue cache size statistics tracking into queue cache implementation once Telemetry APIs and LogStatistics have been reconciled. //IntValueStatistic.FindOrCreate(new StatisticName(StatisticNames.STREAMS_PERSISTENT_STREAM_QUEUE_CACHE_SIZE, statUniquePostfix), () => queueCache != null ? queueCache.Size : 0); }
public override async Task OnDeactivateAsync() { _logger = GetLogger("ProducerEventCountingGrain " + IdentityString); _logger.Info("Producer.OnDeactivateAsync"); _numProducedItems = 0; await base.OnDeactivateAsync(); }
/// <summary> /// Initialize current instance with specific global configuration and logger /// </summary> /// <param name="config"> Global configuration to initialize with </param> /// <param name="logger"> Specific logger to use in current instance </param> /// <returns></returns> public Task Init(GlobalConfiguration config, Logger logger) { deploymentId = config.DeploymentId; serviceId = config.ServiceId; this.logger = logger; storage = new DynamoDBStorage(config.DataConnectionStringForReminders, logger); logger.Info(ErrorCode.ReminderServiceBase, "Initializing AWS DynamoDB Reminders Table"); var secondaryIndex = new GlobalSecondaryIndex { IndexName = SERVICE_ID_INDEX, Projection = new Projection { ProjectionType = ProjectionType.ALL }, KeySchema = new List<KeySchemaElement> { new KeySchemaElement { AttributeName = SERVICE_ID_PROPERTY_NAME, KeyType = KeyType.HASH}, new KeySchemaElement { AttributeName = GRAIN_HASH_PROPERTY_NAME, KeyType = KeyType.RANGE } } }; return storage.InitializeTable(TABLE_NAME_DEFAULT_VALUE, new List<KeySchemaElement> { new KeySchemaElement { AttributeName = REMINDER_ID_PROPERTY_NAME, KeyType = KeyType.HASH }, new KeySchemaElement { AttributeName = GRAIN_HASH_PROPERTY_NAME, KeyType = KeyType.RANGE } }, new List<AttributeDefinition> { new AttributeDefinition { AttributeName = REMINDER_ID_PROPERTY_NAME, AttributeType = ScalarAttributeType.S }, new AttributeDefinition { AttributeName = GRAIN_HASH_PROPERTY_NAME, AttributeType = ScalarAttributeType.N }, new AttributeDefinition { AttributeName = SERVICE_ID_PROPERTY_NAME, AttributeType = ScalarAttributeType.S } }, new List<GlobalSecondaryIndex> { secondaryIndex }); }
private AzureTableBasedGossipChannel gossipTable; // This type is internal public AzureGossipTableTests() { logger = LogManager.GetLogger("AzureGossipTableTests", LoggerType.Application); globalServiceId = Guid.NewGuid(); deploymentId = "test-" + globalServiceId; IPAddress ip; if (!IPAddress.TryParse("127.0.0.1", out ip)) { logger.Error(-1, "Could not parse ip address"); return; } IPEndPoint ep1 = new IPEndPoint(ip, 21111); siloAddress1 = SiloAddress.New(ep1, 0); IPEndPoint ep2 = new IPEndPoint(ip, 21112); siloAddress2 = SiloAddress.New(ep2, 0); logger.Info("DeploymentId={0}", deploymentId); GlobalConfiguration config = new GlobalConfiguration { ServiceId = globalServiceId, ClusterId = "0", DeploymentId = deploymentId, DataConnectionString = TestDefaultConfiguration.DataConnectionString }; gossipTable = new AzureTableBasedGossipChannel(); var done = gossipTable.Initialize(config.ServiceId, config.DataConnectionString); if (!done.Wait(timeout)) { throw new TimeoutException("Could not create/read table."); } }
public override Task OnActivateAsync() { activationGuid = Guid.NewGuid(); logger = GetLogger(String.Format("{0}", activationGuid)); logger.Info("Activate."); return TaskDone.Done; }
public override Task OnActivateAsync() { logger = base.GetLogger("StreamerOutGrain " + base.IdentityString); logger.Info("OnActivateAsync"); numProducedItems = 0; return TaskDone.Done; }
public override Task OnActivateAsync() { Logger = GetLogger("BatchProducerGrain " + IdentityString); Logger.Info("OnActivateAsync"); _numProducedItems = 0; return TaskDone.Done; }
public Task Initialize_2(int ind) { index = ind; logger = GetLogger("ConcurrentGrain-" + index); logger.Info("Initialize(" + index + ")"); return TaskDone.Done; }
public override Task OnActivateAsync() { EventDelay = 1000; Observers = new ObserverSubscriptionManager<ISimpleGrainObserver>(); logger = GetLogger(String.Format("{0}-{1}-{2}", typeof(SimpleObserverableGrain).Name, base.IdentityString, base.RuntimeIdentity)); logger.Info("Activate."); return TaskDone.Done; }
public override Task OnActivateAsync() { logger = base.GetLogger("GeneratedEventReporterGrain " + base.IdentityString); logger.Info("OnActivateAsync"); reports = new Dictionary<Tuple<string, string>, Dictionary<Guid, int>>(); return base.OnActivateAsync(); }
public override Task OnActivateAsync() { grainStore = new Dictionary<string, GrainStateStore>(); base.DelayDeactivation(TimeSpan.FromDays(10 * 365)); // Delay Deactivation for MemoryStorageGrain virtually indefinitely. logger = GetLogger(GetType().Name); logger.Info("OnActivateAsync"); return TaskDone.Done; }
public override Task OnActivateAsync() { logger = GetLogger(String.Format("CollectionTestGrain {0} {1} on {2}.", Identity, Data.ActivationId, RuntimeIdentity)); logger.Info("OnActivateAsync."); activated = DateTime.UtcNow; counter = 0; return TaskDone.Done; }
internal static void LogStartTest(string testName, Guid streamId, string streamProviderName, Logger logger, TestingSiloHost siloHost) { SiloAddress primSilo = siloHost.Primary.Silo.SiloAddress; SiloAddress secSilo = siloHost.Secondary?.Silo.SiloAddress; logger.Info("\n\n**START********************** {0} ********************************* \n\n" + "Running with initial silos Primary={1} Secondary={2} StreamId={3} StreamType={4} \n\n", testName, primSilo, secSilo, streamId, streamProviderName); }
/// <summary> /// This method is called at the end of the process of activating a grain. /// It is called before any messages have been dispatched to the grain. /// For grains with declared persistent state, this method is called after the State property has been populated. /// </summary> public override async Task OnActivateAsync() { await base.OnActivateAsync(); logger = GetLogger($"{typeof (StorageFaultGrain).Name}-{IdentityString}-{RuntimeIdentity}"); readFaults = new Dictionary<GrainReference, Exception>(); writeFaults = new Dictionary<GrainReference, Exception>(); clearfaults = new Dictionary<GrainReference, Exception>(); logger.Info("Activate."); }
public override Task OnActivateAsync() { if (this.GetPrimaryKeyLong() == -2) throw new ArgumentException("Primary key cannot be -2 for this test case"); logger = GetLogger("TestGrain " + Data.Address); label = this.GetPrimaryKeyLong().ToString(); logger.Info("OnActivateAsync"); return base.OnActivateAsync(); }
public override Task OnActivateAsync() { if (this.GetPrimaryKeyLong() == -2) throw new ArgumentException("Primary key cannot be -2 for this test case"); logger = base.GetLogger("StressTestGrain " + base.RuntimeIdentity); label = this.GetPrimaryKeyLong().ToString(); logger.Info("OnActivateAsync"); return TaskDone.Done; }
public override Task OnActivateAsync() { logger = base.GetLogger("FaultableConsumerGrain " + base.IdentityString); logger.Info("OnActivateAsync"); eventsConsumedCount = 0; errorsCount = 0; eventsFailedCount = 0; consumerHandle = null; failPeriodTimer = null; return TaskDone.Done; }
public override Task OnActivateAsync() { myId = Data.ActivationId.ToString();// new Random().Next(); allReminders = new Dictionary<string, IGrainReminder>(); sequence = new Dictionary<string, long>(); logger = GetLogger(string.Format("ReminderTestGrain {0}_{1}", RuntimeIdentity.ToString(), Identity)); period = GetDefaultPeriod(logger); logger.Info("OnActivateAsync."); filePrefix = "g" + Identity.PrimaryKey + "_"; return GetMissingReminders(); }
public override async Task OnActivateAsync() { logger = GetLogger(); logger.Info("OnActivateAsync"); watcher = GrainFactory.GetGrain<IActivateDeactivateWatcherGrain>(0); Assert.IsFalse(doingActivate, "Activate method should have finished"); Assert.IsFalse(doingDeactivate, "Not doing Deactivate yet"); doingActivate = true; await watcher.RecordActivateCall(Data.ActivationId.ToString()); Assert.IsTrue(doingActivate, "Activate method still running"); doingActivate = false; }
public override async Task OnActivateAsync() { logger = base.GetLogger("GeneratedEvenCollectorGrain " + base.IdentityString); logger.Info("OnActivateAsync"); var streamProvider = GetStreamProvider(StreamProviderName); stream = streamProvider.GetStream<GeneratedEvent>(this.GetPrimaryKey(), StreamNamespace); await stream.SubscribeAsync( (e, t) => { counter++; logger.Info("Received a generated event {0}, of {1} events", e, counter); if (e.EventType == GeneratedEvent.GeneratedEventType.Fill) { return TaskDone.Done; } var reporter = this.GrainFactory.GetGrain<IGeneratedEventReporterGrain>(ReporterId); return reporter.ReportResult(this.GetPrimaryKey(), StreamProviderName, StreamNamespace, counter); }); }
public override Task OnActivateAsync() { if (this.GetPrimaryKeyLong() == -2) throw new ArgumentException("Primary key cannot be -2 for this test case"); uniqueId = Guid.NewGuid(); logger = GetLogger("LivenessTestGrain " + uniqueId); label = this.GetPrimaryKeyLong().ToString(); logger.Info("OnActivateAsync"); return base.OnActivateAsync(); }
public static void LogInfo(Orleans.Runtime.Logger orleansLog, string type, string method, string format, params object[] arguments) { #if DEBUG var message = string.Format(format, arguments); var threadId = Thread.CurrentThread.ManagedThreadId; message = string.Format("[{0}]{1}::{2}: {3}", threadId, type, method, message); //Trace.TraceInformation(message); // Debug.WriteLine(message); //Console.WriteLine(message); orleansLog.Info(0, message); #endif }
/// <summary> /// Helper method for testing. /// </summary> /// <param name="providerName"></param> /// <param name="deploymentId"></param> /// <param name="storageConnectionString"></param> /// <param name="logger"></param> /// <returns></returns> public static async Task DeleteAllUsedAzureQueues(string providerName, string deploymentId, string storageConnectionString, Logger logger) { if (deploymentId != null) { var queueMapper = new HashRingBasedStreamQueueMapper(AzureQueueAdapterFactory.DEFAULT_NUM_QUEUES, providerName); List<QueueId> allQueues = queueMapper.GetAllQueues().ToList(); if (logger != null) logger.Info("About to delete all {0} Stream Queues\n", allQueues.Count); foreach (var queueId in allQueues) { var manager = new AzureQueueDataManager(queueId.ToString(), deploymentId, storageConnectionString); await manager.DeleteQueue(); } } }
public override Task OnActivateAsync() { logger = GetLogger(); logger.Info("OnActivateAsync"); watcher = GrainFactory.GetGrain<IActivateDeactivateWatcherGrain>(0); Assert.IsFalse(doingActivate, "Activate method should have finished"); Assert.IsFalse(doingDeactivate, "Not doing Deactivate yet"); doingActivate = true; return watcher.RecordActivateCall(Data.ActivationId.ToString()) .ContinueWith((Task t) => { Assert.IsFalse(t.IsFaulted, "RecordActivateCall failed"); Assert.IsTrue(doingActivate, "Doing Activate"); doingActivate = false; }); }
public async Task Initialize(int ind) { index = ind; logger = GetLogger("ConcurrentGrain-" + index); logger.Info("Initialize(" + index + ")"); if (index == 0) { children = new List<IConcurrentGrain>(); for (int i = 0; i < 1; i++) { IConcurrentGrain grain = GrainFactory.GetGrain<IConcurrentGrain>((new Random()).Next()); await grain.Initialize(i + 1); children.Add(grain); } } }
public virtual Task Init(string name, IProviderRuntime providerRuntime, IProviderConfiguration config) { this.Name = name; string loggerName = string.Format("Storage.{0}-{1}", this.GetType().Name, _id); Log = providerRuntime.GetLogger(loggerName); Log.Info(0, "Init Name={0} Config={1}", name, config); Interlocked.Increment(ref initCount); if (LocalDataStoreInstance.LocalDataStore != null) { // Attached to shared local key store StateStore = LocalDataStoreInstance.LocalDataStore; } else { StateStore = new HierarchicalKeyStore(numKeys); } Log.Info(0, "Finished Init Name={0} Config={1}", name, config); return TaskDone.Done; }
internal PersistentStreamPullingManager( GrainId id, string strProviderName, IStreamProviderRuntime runtime, IQueueAdapterFactory adapterFactory, IStreamQueueBalancer streamQueueBalancer, TimeSpan queueGetPeriod, TimeSpan initQueueTimeout) : base(id, runtime.ExecutingSiloAddress) { if (string.IsNullOrWhiteSpace(strProviderName)) { throw new ArgumentNullException("strProviderName"); } if (runtime == null) { throw new ArgumentNullException("runtime", "IStreamProviderRuntime runtime reference should not be null"); } if (streamQueueBalancer == null) { throw new ArgumentNullException("streamQueueBalancer", "IStreamQueueBalancer streamQueueBalancer reference should not be null"); } queuesToAgentsMap = new Dictionary<QueueId, PersistentStreamPullingAgent>(); streamProviderName = strProviderName; providerRuntime = runtime; this.queueGetPeriod = queueGetPeriod; this.initQueueTimeout = initQueueTimeout; nonReentrancyGuarantor = new AsyncSerialExecutor(); latestRingNotificationSequenceNumber = 0; queueBalancer = streamQueueBalancer; queueAdapterCache = adapterFactory.GetQueueAdapterCache(); logger = providerRuntime.GetLogger(GetType().Name + "-" + streamProviderName); logger.Info((int)ErrorCode.PersistentStreamPullingManager_01, "Created {0} for Stream Provider {1}.", GetType().Name, streamProviderName); IntValueStatistic.FindOrCreate(new StatisticName(StatisticNames.STREAMS_PERSISTENT_STREAM_NUM_PULLING_AGENTS, strProviderName), () => queuesToAgentsMap.Count); }
public GatewayManager(ClientConfiguration cfg, IGatewayListProvider gatewayListProvider) { config = cfg; knownDead = new Dictionary<Uri, DateTime>(); rand = new SafeRandom(); logger = LogManager.GetLogger("Messaging.GatewayManager", LoggerType.Runtime); lockable = new object(); gatewayRefreshCallInitiated = false; ListProvider = gatewayListProvider; var knownGateways = ListProvider.GetGateways().GetResult(); if (knownGateways.Count == 0) { string gatewayProviderType = gatewayListProvider.GetType().FullName; string err = String.Format("Could not find any gateway in {0}. Orleans client cannot initialize.", gatewayProviderType); logger.Error(ErrorCode.GatewayManager_NoGateways, err); throw new OrleansException(err); } logger.Info(ErrorCode.GatewayManager_FoundKnownGateways, "Found {0} knownGateways from Gateway listProvider {1}", knownGateways.Count, Utils.EnumerableToString(knownGateways)); if (ListProvider is IGatewayListObservable) { ((IGatewayListObservable)ListProvider).SubscribeToGatewayNotificationEvents(this); } roundRobinCounter = cfg.PreferedGatewayIndex >= 0 ? cfg.PreferedGatewayIndex : rand.Next(knownGateways.Count); cachedLiveGateways = knownGateways; lastRefreshTime = DateTime.UtcNow; if (ListProvider.IsUpdatable) { gatewayRefreshTimer = new SafeTimer(RefreshSnapshotLiveGateways_TimerCallback, null, config.GatewayListRefreshPeriod, config.GatewayListRefreshPeriod); } }
private async Task LogGrainIdentity(Logger logger, ILivenessTestGrain grain) { logger.Info("Grain {0}, activation {1} on {2}", await grain.GetGrainReference(), await grain.GetUniqueId(), await grain.GetRuntimeInstanceId()); }
private void DoStart() { lock (lockable) { if (!SystemStatus.Current.Equals(SystemStatus.Created)) { throw new InvalidOperationException(String.Format("Calling Silo.Start() on a silo which is not in the Created state. This silo is in the {0} state.", SystemStatus.Current)); } SystemStatus.Current = SystemStatus.Starting; } logger.Info(ErrorCode.SiloStarting, "Silo Start()"); // Hook up to receive notification of process exit / Ctrl-C events AppDomain.CurrentDomain.ProcessExit += HandleProcessExit; Console.CancelKeyPress += HandleProcessExit; ConfigureThreadPoolAndServicePointSettings(); // This has to start first so that the directory system target factory gets loaded before we start the router. typeManager.Start(); InsideRuntimeClient.Current.Start(); // The order of these 4 is pretty much arbitrary. scheduler.Start(); messageCenter.Start(); incomingPingAgent.Start(); incomingSystemAgent.Start(); incomingAgent.Start(); LocalGrainDirectory.Start(); // Set up an execution context for this thread so that the target creation steps can use asynch values. RuntimeContext.InitializeMainThread(); SiloProviderRuntime.Initialize(GlobalConfig, SiloIdentity, grainFactory, Services); InsideRuntimeClient.Current.CurrentStreamProviderRuntime = SiloProviderRuntime.Instance; statisticsProviderManager = new StatisticsProviderManager("Statistics", SiloProviderRuntime.Instance); string statsProviderName = statisticsProviderManager.LoadProvider(GlobalConfig.ProviderConfigurations) .WaitForResultWithThrow(initTimeout); if (statsProviderName != null) { LocalConfig.StatisticsProviderName = statsProviderName; } allSiloProviders.AddRange(statisticsProviderManager.GetProviders()); // can call SetSiloMetricsTableDataManager only after MessageCenter is created (dependency on this.SiloAddress). siloStatistics.SetSiloStatsTableDataManager(this, nodeConfig).WaitWithThrow(initTimeout); siloStatistics.SetSiloMetricsTableDataManager(this, nodeConfig).WaitWithThrow(initTimeout); IMembershipTable membershipTable = membershipFactory.GetMembershipTable(GlobalConfig.LivenessType, GlobalConfig.MembershipTableAssembly); membershipOracle = membershipFactory.CreateMembershipOracle(this, membershipTable); multiClusterOracle = multiClusterFactory.CreateGossipOracle(this).WaitForResultWithThrow(initTimeout); // This has to follow the above steps that start the runtime components CreateSystemTargets(); InjectDependencies(); // Validate the configuration. GlobalConfig.Application.ValidateConfiguration(logger); // ensure this runs in the grain context, wait for it to complete scheduler.QueueTask(CreateSystemGrains, catalog.SchedulingContext) .WaitWithThrow(initTimeout); if (logger.IsVerbose) { logger.Verbose("System grains created successfully."); } // Initialize storage providers once we have a basic silo runtime environment operating storageProviderManager = new StorageProviderManager(grainFactory, Services); scheduler.QueueTask( () => storageProviderManager.LoadStorageProviders(GlobalConfig.ProviderConfigurations), providerManagerSystemTarget.SchedulingContext) .WaitWithThrow(initTimeout); catalog.SetStorageManager(storageProviderManager); allSiloProviders.AddRange(storageProviderManager.GetProviders()); if (logger.IsVerbose) { logger.Verbose("Storage provider manager created successfully."); } // Load and init stream providers before silo becomes active var siloStreamProviderManager = (StreamProviderManager)grainRuntime.StreamProviderManager; scheduler.QueueTask( () => siloStreamProviderManager.LoadStreamProviders(GlobalConfig.ProviderConfigurations, SiloProviderRuntime.Instance), providerManagerSystemTarget.SchedulingContext) .WaitWithThrow(initTimeout); InsideRuntimeClient.Current.CurrentStreamProviderManager = siloStreamProviderManager; allSiloProviders.AddRange(siloStreamProviderManager.GetProviders()); if (logger.IsVerbose) { logger.Verbose("Stream provider manager created successfully."); } ISchedulingContext statusOracleContext = ((SystemTarget)LocalSiloStatusOracle).SchedulingContext; bool waitForPrimaryToStart = globalConfig.PrimaryNodeIsRequired && siloType != SiloType.Primary; if (waitForPrimaryToStart) // only in MembershipTableGrain case. { scheduler.QueueTask(() => membershipFactory.WaitForTableToInit(membershipTable), statusOracleContext) .WaitWithThrow(initTimeout); } scheduler.QueueTask(() => membershipTable.InitializeMembershipTable(GlobalConfig, true, LogManager.GetLogger(membershipTable.GetType().Name)), statusOracleContext) .WaitWithThrow(initTimeout); scheduler.QueueTask(() => LocalSiloStatusOracle.Start(), statusOracleContext) .WaitWithThrow(initTimeout); if (logger.IsVerbose) { logger.Verbose("Local silo status oracle created successfully."); } scheduler.QueueTask(LocalSiloStatusOracle.BecomeActive, statusOracleContext) .WaitWithThrow(initTimeout); if (logger.IsVerbose) { logger.Verbose("Local silo status oracle became active successfully."); } //if running in multi cluster scenario, start the MultiClusterNetwork Oracle if (GlobalConfig.HasMultiClusterNetwork) { logger.Info("Creating multicluster oracle with my ServiceId={0} and ClusterId={1}.", GlobalConfig.ServiceId, GlobalConfig.ClusterId); ISchedulingContext clusterStatusContext = ((SystemTarget)multiClusterOracle).SchedulingContext; scheduler.QueueTask(() => multiClusterOracle.Start(LocalSiloStatusOracle), clusterStatusContext) .WaitWithThrow(initTimeout); if (logger.IsVerbose) { logger.Verbose("multicluster oracle created successfully."); } } try { siloStatistics.Start(LocalConfig); if (logger.IsVerbose) { logger.Verbose("Silo statistics manager started successfully."); } // Finally, initialize the deployment load collector, for grains with load-based placement scheduler.QueueTask(DeploymentLoadPublisher.Instance.Start, DeploymentLoadPublisher.Instance.SchedulingContext) .WaitWithThrow(initTimeout); if (logger.IsVerbose) { logger.Verbose("Silo deployment load publisher started successfully."); } // Start background timer tick to watch for platform execution stalls, such as when GC kicks in platformWatchdog = new Watchdog(nodeConfig.StatisticsLogWriteInterval, healthCheckParticipants); platformWatchdog.Start(); if (logger.IsVerbose) { logger.Verbose("Silo platform watchdog started successfully."); } if (reminderService != null) { // so, we have the view of the membership in the consistentRingProvider. We can start the reminder service scheduler.QueueTask(reminderService.Start, ((SystemTarget)reminderService).SchedulingContext) .WaitWithThrow(initTimeout); if (logger.IsVerbose) { logger.Verbose("Reminder service started successfully."); } } bootstrapProviderManager = new BootstrapProviderManager(); scheduler.QueueTask( () => bootstrapProviderManager.LoadAppBootstrapProviders(GlobalConfig.ProviderConfigurations), providerManagerSystemTarget.SchedulingContext) .WaitWithThrow(initTimeout); BootstrapProviders = bootstrapProviderManager.GetProviders(); // Data hook for testing & diagnotics allSiloProviders.AddRange(BootstrapProviders); if (logger.IsVerbose) { logger.Verbose("App bootstrap calls done successfully."); } // Start stream providers after silo is active (so the pulling agents don't start sending messages before silo is active). // also after bootstrap provider started so bootstrap provider can initialize everything stream before events from this silo arrive. scheduler.QueueTask(siloStreamProviderManager.StartStreamProviders, providerManagerSystemTarget.SchedulingContext) .WaitWithThrow(initTimeout); if (logger.IsVerbose) { logger.Verbose("Stream providers started successfully."); } // Now that we're active, we can start the gateway var mc = messageCenter as MessageCenter; if (mc != null) { mc.StartGateway(clientRegistrar); } if (logger.IsVerbose) { logger.Verbose("Message gateway service started successfully."); } SystemStatus.Current = SystemStatus.Running; } catch (Exception exc) { SafeExecute(() => logger.Error(ErrorCode.Runtime_Error_100330, String.Format("Error starting silo {0}. Going to FastKill().", SiloAddress), exc)); FastKill(); // if failed after Membership became active, mark itself as dead in Membership abale. throw; } if (logger.IsVerbose) { logger.Verbose("Silo.Start complete: System status = {0}", SystemStatus.Current); } }
private List <string> EnumerateApprovedAssemblies() { var assemblies = new List <string>(); foreach (var i in dirEnumArgs) { var pathName = i.Key; var searchOption = i.Value; if (!Directory.Exists(pathName)) { logger.Warn(ErrorCode.Loader_DirNotFound, "Unable to find directory {0}; skipping.", pathName); continue; } logger.Info( searchOption == SearchOption.TopDirectoryOnly ? "Searching for assemblies in {0}..." : "Recursively searching for assemblies in {0}...", pathName); var candidates = Directory.EnumerateFiles(pathName, "*.dll", searchOption) .Select(Path.GetFullPath) .Distinct() .ToArray(); // This is a workaround for the behavior of ReflectionOnlyLoad/ReflectionOnlyLoadFrom // that appear not to automatically resolve dependencies. // We are trying to pre-load all dlls we find in the folder, so that if one of these // assemblies happens to be a dependency of an assembly we later on call // Assembly.DefinedTypes on, the dependency will be already loaded and will get // automatically resolved. Ugly, but seems to solve the problem. foreach (var j in candidates) { try { if (logger.IsVerbose) { logger.Verbose("Trying to pre-load {0} to reflection-only context.", j); } Assembly.ReflectionOnlyLoadFrom(j); } catch (Exception) { if (logger.IsVerbose) { logger.Verbose("Failed to pre-load assembly {0} in reflection-only context.", j); } } } foreach (var j in candidates) { if (AssemblyPassesLoadCriteria(j)) { assemblies.Add(j); } } } return(assemblies); }
public static void LogInfoForDebug(Orleans.Runtime.Logger orleansLog, string format, params object[] arguments) { #if DEBUG orleansLog.Info(0, format, arguments); #endif }
internal Silo(string name, SiloType siloType, ClusterConfiguration config, ILocalDataStore keyStore) { SystemStatus.Current = SystemStatus.Creating; CurrentSilo = this; var startTime = DateTime.UtcNow; this.siloType = siloType; Name = name; siloTerminatedEvent = new ManualResetEvent(false); OrleansConfig = config; globalConfig = config.Globals; config.OnConfigChange("Defaults", () => nodeConfig = config.GetOrCreateNodeConfigurationForSilo(name)); if (!LogManager.IsInitialized) { LogManager.Initialize(nodeConfig); } config.OnConfigChange("Defaults/Tracing", () => LogManager.Initialize(nodeConfig, true), false); MultiClusterRegistrationStrategy.Initialize(config.Globals); ActivationData.Init(config, nodeConfig); StatisticsCollector.Initialize(nodeConfig); SerializationManager.Initialize(globalConfig.SerializationProviders, this.globalConfig.FallbackSerializationProvider); initTimeout = globalConfig.MaxJoinAttemptTime; if (Debugger.IsAttached) { initTimeout = StandardExtensions.Max(TimeSpan.FromMinutes(10), globalConfig.MaxJoinAttemptTime); stopTimeout = initTimeout; } IPEndPoint here = nodeConfig.Endpoint; int generation = nodeConfig.Generation; if (generation == 0) { generation = SiloAddress.AllocateNewGeneration(); nodeConfig.Generation = generation; } LogManager.MyIPEndPoint = here; logger = LogManager.GetLogger("Silo", LoggerType.Runtime); logger.Info(ErrorCode.SiloGcSetting, "Silo starting with GC settings: ServerGC={0} GCLatencyMode={1}", GCSettings.IsServerGC, Enum.GetName(typeof(GCLatencyMode), GCSettings.LatencyMode)); if (!GCSettings.IsServerGC || !GCSettings.LatencyMode.Equals(GCLatencyMode.Batch)) { logger.Warn(ErrorCode.SiloGcWarning, "Note: Silo not running with ServerGC turned on or with GCLatencyMode.Batch enabled - recommend checking app config : <configuration>-<runtime>-<gcServer enabled=\"true\"> and <configuration>-<runtime>-<gcConcurrent enabled=\"false\"/>"); logger.Warn(ErrorCode.SiloGcWarning, "Note: ServerGC only kicks in on multi-core systems (settings enabling ServerGC have no effect on single-core machines)."); } logger.Info(ErrorCode.SiloInitializing, "-------------- Initializing {0} silo on host {1} MachineName {2} at {3}, gen {4} --------------", siloType, nodeConfig.DNSHostName, Environment.MachineName, here, generation); logger.Info(ErrorCode.SiloInitConfig, "Starting silo {0} with the following configuration= " + Environment.NewLine + "{1}", name, config.ToString(name)); if (keyStore != null) { // Re-establish reference to shared local key store in this app domain LocalDataStoreInstance.LocalDataStore = keyStore; } // Configure DI using Startup type bool usingCustomServiceProvider; Services = StartupBuilder.ConfigureStartup(nodeConfig.StartupTypeName, out usingCustomServiceProvider); healthCheckParticipants = new List <IHealthCheckParticipant>(); allSiloProviders = new List <IProvider>(); BufferPool.InitGlobalBufferPool(globalConfig); PlacementStrategy.Initialize(globalConfig); UnobservedExceptionsHandlerClass.SetUnobservedExceptionHandler(UnobservedExceptionHandler); AppDomain.CurrentDomain.UnhandledException += (obj, ev) => DomainUnobservedExceptionHandler(obj, (Exception)ev.ExceptionObject); try { grainFactory = Services.GetRequiredService <GrainFactory>(); } catch (InvalidOperationException exc) { logger.Error(ErrorCode.SiloStartError, "Exception during Silo.Start, GrainFactory was not registered in Dependency Injection container", exc); throw; } typeManager = new GrainTypeManager( here.Address.Equals(IPAddress.Loopback), grainFactory, new SiloAssemblyLoader(OrleansConfig.Defaults.AdditionalAssemblyDirectories)); // Performance metrics siloStatistics = new SiloStatisticsManager(globalConfig, nodeConfig); config.OnConfigChange("Defaults/LoadShedding", () => siloStatistics.MetricsTable.NodeConfig = nodeConfig, false); // The scheduler scheduler = new OrleansTaskScheduler(globalConfig, nodeConfig); healthCheckParticipants.Add(scheduler); // Initialize the message center var mc = new MessageCenter(here, generation, globalConfig, siloStatistics.MetricsTable); if (nodeConfig.IsGatewayNode) { mc.InstallGateway(nodeConfig.ProxyGatewayEndpoint); } messageCenter = mc; SiloIdentity = SiloAddress.ToLongString(); // GrainRuntime can be created only here, after messageCenter was created. grainRuntime = new GrainRuntime( globalConfig.ServiceId, SiloIdentity, grainFactory, new TimerRegistry(), new ReminderRegistry(), new StreamProviderManager(), Services); // Now the router/directory service // This has to come after the message center //; note that it then gets injected back into the message center.; localGrainDirectory = new LocalGrainDirectory(this); RegistrarManager.InitializeGrainDirectoryManager(localGrainDirectory, globalConfig.GlobalSingleInstanceNumberRetries); // Now the activation directory. // This needs to know which router to use so that it can keep the global directory in synch with the local one. activationDirectory = new ActivationDirectory(); // Now the consistent ring provider RingProvider = GlobalConfig.UseVirtualBucketsConsistentRing ? (IConsistentRingProvider) new VirtualBucketsRingProvider(SiloAddress, GlobalConfig.NumVirtualBucketsConsistentRing) : new ConsistentRingProvider(SiloAddress); // to preserve backwards compatibility, only use the service provider to inject grain dependencies if the user supplied his own // service provider, meaning that he is explicitly opting into it. var grainCreator = new GrainCreator(grainRuntime, usingCustomServiceProvider ? Services : null); Action <Dispatcher> setDispatcher; catalog = new Catalog(Constants.CatalogId, SiloAddress, Name, LocalGrainDirectory, typeManager, scheduler, activationDirectory, config, grainCreator, out setDispatcher); var dispatcher = new Dispatcher(scheduler, messageCenter, catalog, config); setDispatcher(dispatcher); RuntimeClient.Current = new InsideRuntimeClient( dispatcher, catalog, LocalGrainDirectory, SiloAddress, config, RingProvider, typeManager, grainFactory); messageCenter.RerouteHandler = InsideRuntimeClient.Current.RerouteMessage; messageCenter.SniffIncomingMessage = InsideRuntimeClient.Current.SniffIncomingMessage; siloStatistics.MetricsTable.Scheduler = scheduler; siloStatistics.MetricsTable.ActivationDirectory = activationDirectory; siloStatistics.MetricsTable.ActivationCollector = catalog.ActivationCollector; siloStatistics.MetricsTable.MessageCenter = messageCenter; DeploymentLoadPublisher.CreateDeploymentLoadPublisher(this, globalConfig); PlacementDirectorsManager.CreatePlacementDirectorsManager(globalConfig); // Now the incoming message agents incomingSystemAgent = new IncomingMessageAgent(Message.Categories.System, messageCenter, activationDirectory, scheduler, dispatcher); incomingPingAgent = new IncomingMessageAgent(Message.Categories.Ping, messageCenter, activationDirectory, scheduler, dispatcher); incomingAgent = new IncomingMessageAgent(Message.Categories.Application, messageCenter, activationDirectory, scheduler, dispatcher); membershipFactory = new MembershipFactory(); multiClusterFactory = new MultiClusterOracleFactory(); reminderFactory = new LocalReminderServiceFactory(); SystemStatus.Current = SystemStatus.Created; StringValueStatistic.FindOrCreate(StatisticNames.SILO_START_TIME, () => LogFormatter.PrintDate(startTime)); // this will help troubleshoot production deployment when looking at MDS logs. logger.Info(ErrorCode.SiloInitializingFinished, "-------------- Started silo {0}, ConsistentHashCode {1:X} --------------", SiloAddress.ToLongString(), SiloAddress.GetConsistentHashCode()); }