Пример #1
0
 internal Dispatcher(
     OrleansTaskScheduler scheduler,
     ISiloMessageCenter transport,
     Catalog catalog,
     ClusterConfiguration config,
     PlacementDirectorsManager placementDirectorsManager,
     ILocalGrainDirectory localGrainDirectory,
     MessageFactory messagefactory,
     SerializationManager serializationManager,
     CompatibilityDirectorManager compatibilityDirectorManager,
     ILoggerFactory loggerFactory)
 {
     this.loggerFactory                = loggerFactory;
     this.scheduler                    = scheduler;
     this.catalog                      = catalog;
     Transport                         = transport;
     this.config                       = config;
     this.invokeWorkItemLogger         = loggerFactory.CreateLogger <InvokeWorkItem>();
     this.placementDirectorsManager    = placementDirectorsManager;
     this.localGrainDirectory          = localGrainDirectory;
     this.messagefactory               = messagefactory;
     this.serializationManager         = serializationManager;
     this.compatibilityDirectorManager = compatibilityDirectorManager;
     logger = new LoggerWrapper <Dispatcher>(loggerFactory);
     random = new SafeRandom();
 }
Пример #2
0
        internal Dispatcher(
            OrleansTaskScheduler scheduler,
            ISiloMessageCenter transport,
            Catalog catalog,
            ClusterConfiguration config,
            PlacementDirectorsManager placementDirectorsManager,
            ILocalGrainDirectory localGrainDirectory,
            MessageFactory messagefactory,
            SerializationManager serializationManager,
            CompatibilityDirectorManager compatibilityDirectorManager)
        {
            this.scheduler = scheduler;
            this.catalog   = catalog;
            Transport      = transport;
            this.config    = config;
            this.placementDirectorsManager    = placementDirectorsManager;
            this.localGrainDirectory          = localGrainDirectory;
            this.messagefactory               = messagefactory;
            this.serializationManager         = serializationManager;
            this.compatibilityDirectorManager = compatibilityDirectorManager;
            logger = LogManager.GetLogger("Dispatcher", LoggerType.Runtime);
            rejectionInjectionRate = config.Globals.RejectionInjectionRate;
            double messageLossInjectionRate = config.Globals.MessageLossInjectionRate;

            errorInjection     = rejectionInjectionRate > 0.0d || messageLossInjectionRate > 0.0d;
            errorInjectionRate = rejectionInjectionRate + messageLossInjectionRate;
            random             = new SafeRandom();
        }
        internal PersistentStreamPullingAgent(
            GrainId id, 
            string strProviderName,
            IStreamProviderRuntime runtime,
            QueueId queueId, 
            TimeSpan queueGetPeriod,
            TimeSpan initQueueTimeout,
            TimeSpan maxDeliveryTime)
            : 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 = runtime.PubSub(StreamPubSubType.GrainBased);
            pubSubCache = new Dictionary<StreamId, StreamConsumerCollection>();
            safeRandom = new SafeRandom();
            this.queueGetPeriod = queueGetPeriod;
            this.initQueueTimeout = initQueueTimeout;
            this.maxDeliveryTime = maxDeliveryTime;
            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());

            numReadMessagesCounter = CounterStatistic.FindOrCreate(new StatisticName(StatisticNames.STREAMS_PERSISTENT_STREAM_NUM_READ_MESSAGES, strProviderName));
            numSentMessagesCounter = CounterStatistic.FindOrCreate(new StatisticName(StatisticNames.STREAMS_PERSISTENT_STREAM_NUM_SENT_MESSAGES, strProviderName));
        }
        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);
        }
Пример #5
0
 internal Dispatcher(
     OrleansTaskScheduler scheduler,
     ISiloMessageCenter transport,
     Catalog catalog,
     IOptions <SiloMessagingOptions> messagingOptions,
     PlacementDirectorsManager placementDirectorsManager,
     ILocalGrainDirectory localGrainDirectory,
     MessageFactory messagefactory,
     SerializationManager serializationManager,
     CompatibilityDirectorManager compatibilityDirectorManager,
     ILoggerFactory loggerFactory,
     IOptions <SchedulingOptions> schedulerOptions)
 {
     this.scheduler                    = scheduler;
     this.catalog                      = catalog;
     Transport                         = transport;
     this.messagingOptions             = messagingOptions.Value;
     this.invokeWorkItemLogger         = loggerFactory.CreateLogger <InvokeWorkItem>();
     this.placementDirectorsManager    = placementDirectorsManager;
     this.localGrainDirectory          = localGrainDirectory;
     this.messagefactory               = messagefactory;
     this.serializationManager         = serializationManager;
     this.compatibilityDirectorManager = compatibilityDirectorManager;
     this.schedulingOptions            = schedulerOptions.Value;
     logger = loggerFactory.CreateLogger <Dispatcher>();
     random = new SafeRandom();
 }
Пример #6
0
 public SingleStreamTestRunner(string streamProvider, int testNum = 0, bool fullTest = true)
 {
     this.streamProviderName = streamProvider;
     this.logger = TraceLogger.GetLogger("SingleStreamTestRunner", TraceLogger.LoggerType.Application);
     this.testNumber = testNum;
     this.runFullTest = fullTest;
     this.random = TestConstants.random;
 }
Пример #7
0
        public static TimeSpan NextTimeSpan(this SafeRandom random, TimeSpan timeSpan)
        {
            if (timeSpan <= TimeSpan.Zero)
            {
                throw new ArgumentOutOfRangeException("timeSpan", timeSpan, "SafeRandom.NextTimeSpan timeSpan must be a positive number.");
            }
            double ticksD = ((double)timeSpan.Ticks) * random.NextDouble();
            long   ticks  = checked ((long)ticksD);

            return(TimeSpan.FromTicks(ticks));
        }
Пример #8
0
        public async Task AsyncSerialExecutorTests_Small()
        {
            AsyncSerialExecutor executor = new AsyncSerialExecutor();
            List<Task> tasks = new List<Task>();
            random = new SafeRandom();
            operationsInProgress = 0;

            tasks.Add(executor.AddNext(() => Operation(1)));
            tasks.Add(executor.AddNext(() => Operation(2)));
            tasks.Add(executor.AddNext(() => Operation(3)));

            await Task.WhenAll(tasks);
        }
 private void Start()
 {
     var random = new SafeRandom();
     var randomOffset = random.NextTimeSpan(orleansConfig.Globals.ClientRegistrationRefresh);
     clientRefreshTimer = GrainTimer.FromTaskCallback(
             OnClientRefreshTimer, 
             null, 
             randomOffset, 
             orleansConfig.Globals.ClientRegistrationRefresh, 
             "ClientObserverRegistrar.ClientRefreshTimer");
     clientRefreshTimer.Start();
     if (logger.IsVerbose) { logger.Verbose("Client registrar service started successfully."); }
 }
Пример #10
0
 public async Task AsyncSerialExecutorTests_SerialSubmit()
 {
     AsyncSerialExecutor executor = new AsyncSerialExecutor();
     random = new SafeRandom();
     List<Task> tasks = new List<Task>();
     for (int i = 0; i < 10; i++)
     {
         int capture = i;
         logger.Info("Submitting Task {0}.", capture);
         tasks.Add(executor.AddNext(() => Operation(capture)));
     }
     await Task.WhenAll(tasks);
 }
Пример #11
0
 public Task Start()
 {
     var random = new SafeRandom();
     var randomOffset = random.NextTimeSpan(orleansConfig.Globals.ClientRegistrationRefresh);
     clientRefreshTimer = GrainTimer.FromTaskCallback(
             OnClientRefreshTimer, 
             null, 
             randomOffset, 
             orleansConfig.Globals.ClientRegistrationRefresh, 
             "ClientObserverRegistrar.ClientRefreshTimer");
     clientRefreshTimer.Start();
     return TaskDone.Done;
 }
Пример #12
0
        public Task Start()
        {
            var random       = new SafeRandom();
            var randomOffset = random.NextTimeSpan(orleansConfig.Globals.ClientRegistrationRefresh);

            clientRefreshTimer = GrainTimer.FromTaskCallback(
                OnClientRefreshTimer,
                null,
                randomOffset,
                orleansConfig.Globals.ClientRegistrationRefresh,
                "ClientObserverRegistrar.ClientRefreshTimer");
            clientRefreshTimer.Start();
            return(TaskDone.Done);
        }
Пример #13
0
        public static TimeSpan NextTimeSpan(this SafeRandom random, TimeSpan minValue, TimeSpan maxValue)
        {
            if (minValue <= TimeSpan.Zero)
            {
                throw new ArgumentOutOfRangeException("minValue", minValue, "SafeRandom.NextTimeSpan minValue must be a positive number.");
            }
            if (minValue >= maxValue)
            {
                throw new ArgumentOutOfRangeException("minValue", minValue, "SafeRandom.NextTimeSpan minValue must be greater than maxValue.");
            }
            var span = maxValue - minValue;

            return(minValue + random.NextTimeSpan(span));
        }
Пример #14
0
        internal static async Task ReminderTableTest(IReminderTable reminderTable)
        {
            Guid guid = Guid.NewGuid();
            var results = await Task.WhenAll(Enumerable.Range(0, 10).
                Select(x => reminderTable.UpsertRow(CreateReminder(MakeTestGrainReference(guid), "0"))));

            Assert.AreEqual(results.Distinct().Count(), results.Length);

            await Task.WhenAll(Enumerable.Range(1, 999).Select(async i =>
            {
                GrainReference grainRef = MakeTestGrainReference(Guid.NewGuid());
                await reminderTable.UpsertRow(CreateReminder(grainRef, i.ToString()));
            }));

            var rows = await reminderTable.ReadRows(0, uint.MaxValue);

            Assert.AreEqual(rows.Reminders.Count, 1000);

            rows = await reminderTable.ReadRows(0, 0);

            Assert.AreEqual(rows.Reminders.Count, 1000);

            var remindersHashes = rows.Reminders.Select(r => r.GrainRef.GetUniformHashCode()).ToArray();
            
            SafeRandom random = new SafeRandom();

            await Task.WhenAll(Enumerable.Repeat(
                        TestRemindersHashInterval(reminderTable, (uint) random.Next(), (uint) random.Next(),
                            remindersHashes), 1000));

            var reminder = rows.Reminders.First();

            var shouldExist = await reminderTable.ReadRow(reminder.GrainRef, reminder.ReminderName);

            Assert.IsNotNull(shouldExist);

            string etagTemp = reminder.ETag;

            reminder.ETag = await reminderTable.UpsertRow(reminder);

            var removeRowRes = await reminderTable.RemoveRow(reminder.GrainRef, reminder.ReminderName, etagTemp);
            Assert.IsFalse(removeRowRes, "should have failed. Etag is wrong");
            removeRowRes = await reminderTable.RemoveRow(reminder.GrainRef, "bla", reminder.ETag);
            Assert.IsFalse(removeRowRes, "should have failed. reminder name is wrong");
            removeRowRes = await reminderTable.RemoveRow(reminder.GrainRef, reminder.ReminderName, reminder.ETag);
            Assert.IsTrue(removeRowRes, "should have succeeded. Etag is right");
            removeRowRes = await reminderTable.RemoveRow(reminder.GrainRef, reminder.ReminderName, reminder.ETag);
            Assert.IsFalse(removeRowRes, "should have failed. reminder shouldn't exist");
        }
Пример #15
0
        private void Start()
        {
            var random       = new SafeRandom();
            var randomOffset = random.NextTimeSpan(orleansConfig.Globals.ClientRegistrationRefresh);

            this.RegisterTimer(
                this.OnClientRefreshTimer,
                null,
                randomOffset,
                orleansConfig.Globals.ClientRegistrationRefresh,
                "ClientObserverRegistrar.ClientRefreshTimer");
            if (logger.IsVerbose)
            {
                logger.Verbose("Client registrar service started successfully.");
            }
        }
Пример #16
0
        public async Task Start()
        {
            logger.Info("Starting DeploymentLoadPublisher.");
            if (statisticsRefreshTime > TimeSpan.Zero)
            {
                var random = new SafeRandom();
                // Randomize PublishStatistics timer,
                // but also upon start publish my stats to everyone and take everyone's stats for me to start with something.
                var randomTimerOffset = random.NextTimeSpan(statisticsRefreshTime);
                this.RegisterTimer(PublishStatistics, null, randomTimerOffset, statisticsRefreshTime, "DeploymentLoadPublisher.PublishStatisticsTimer");
            }
            await RefreshStatistics();
            await PublishStatistics(null);

            logger.Info("Started DeploymentLoadPublisher.");
        }
Пример #17
0
        private void Start()
        {
            var random       = new SafeRandom();
            var randomOffset = random.NextTimeSpan(this.messagingOptions.ClientRegistrationRefresh);

            this.refreshTimer = this.RegisterTimer(
                this.OnClientRefreshTimer,
                null,
                randomOffset,
                this.messagingOptions.ClientRegistrationRefresh,
                "ClientObserverRegistrar.ClientRefreshTimer");
            if (logger.IsEnabled(LogLevel.Debug))
            {
                logger.Debug("Client registrar service started successfully.");
            }
        }
Пример #18
0
 public async Task Start()
 {
     logger.Info("Starting DeploymentLoadPublisher.");
     if (statisticsRefreshTime > TimeSpan.Zero)
     {
         var random = new SafeRandom();
         // Randomize PublishStatistics timer,
         // but also upon start publish my stats to everyone and take everyone's stats for me to start with something.
         var randomTimerOffset = random.NextTimeSpan(statisticsRefreshTime);
         var t = GrainTimer.FromTaskCallback(PublishStatistics, null, randomTimerOffset, statisticsRefreshTime, "DeploymentLoadPublisher.PublishStatisticsTimer");
         t.Start();
     }
     await RefreshStatistics();
     await PublishStatistics(null);
     logger.Info("Started DeploymentLoadPublisher.");
 }
Пример #19
0
 public Dispatcher(
     OrleansTaskScheduler scheduler, 
     ISiloMessageCenter transport, 
     Catalog catalog, 
     ClusterConfiguration config)
 {
     Scheduler = scheduler;
     this.catalog = catalog;
     Transport = transport;
     this.config = config;
     logger = TraceLogger.GetLogger("Dispatcher", TraceLogger.LoggerType.Runtime);
     rejectionInjectionRate = config.Globals.RejectionInjectionRate;
     double messageLossInjectionRate = config.Globals.MessageLossInjectionRate;
     errorInjection = rejectionInjectionRate > 0.0d || messageLossInjectionRate > 0.0d;
     errorInjectionRate = rejectionInjectionRate + messageLossInjectionRate;
     random = new SafeRandom();
 }
Пример #20
0
        public Dispatcher(
            OrleansTaskScheduler scheduler,
            ISiloMessageCenter transport,
            Catalog catalog,
            ClusterConfiguration config)
        {
            Scheduler              = scheduler;
            this.catalog           = catalog;
            Transport              = transport;
            this.config            = config;
            logger                 = TraceLogger.GetLogger("Dispatcher", TraceLogger.LoggerType.Runtime);
            rejectionInjectionRate = config.Globals.RejectionInjectionRate;
            double messageLossInjectionRate = config.Globals.MessageLossInjectionRate;

            errorInjection     = rejectionInjectionRate > 0.0d || messageLossInjectionRate > 0.0d;
            errorInjectionRate = rejectionInjectionRate + messageLossInjectionRate;
            random             = new SafeRandom();
        }
Пример #21
0
        public GatewayManager(ClientConfiguration cfg, IGatewayListProvider gatewayListProvider)
        {
            config = cfg;
            knownDead = new Dictionary<Uri, DateTime>();
            rand = new SafeRandom();
            logger = TraceLogger.GetLogger("Messaging.GatewayManager", TraceLogger.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);
            }
        }
Пример #22
0
        internal async Task RemindersRange(int iterations=1000)
        {
            await Task.WhenAll(Enumerable.Range(1, iterations).Select(async i =>
            {
                GrainReference grainRef = MakeTestGrainReference();
                await remindersTable.UpsertRow(CreateReminder(grainRef, i.ToString()));
            }));

            var rows = await remindersTable.ReadRows(0, uint.MaxValue);

            Assert.AreEqual(rows.Reminders.Count, iterations);

            rows = await remindersTable.ReadRows(0, 0);

            Assert.AreEqual(rows.Reminders.Count, iterations);

            var remindersHashes = rows.Reminders.Select(r => r.GrainRef.GetUniformHashCode()).ToArray();
            
            SafeRandom random = new SafeRandom();

            await Task.WhenAll(Enumerable.Range(0, iterations).Select(i =>
                TestRemindersHashInterval(remindersTable, (uint)random.Next(), (uint)random.Next(),
                    remindersHashes)));
        }
Пример #23
0
        public async Task InterleavingConsistencyTest(int numItems)
        {
            TimeSpan delay = TimeSpan.FromMilliseconds(1);
            SafeRandom random = new SafeRandom();

            List<Task> getFileMetadataPromises = new List<Task>(numItems*2);
            Dictionary<int, string> fileMetadatas = new Dictionary<int, string>(numItems*2);

            for (int i = 0; i < numItems; i++)
            {
                int capture = i;
                Func<Task> func = (
                    async () =>
                    {
                        await Task.Delay(random.NextTimeSpan(delay));
                        int fileMetadata = capture;
                        if ((fileMetadata%2) == 0)
                        {
                            fileMetadatas.Add(fileMetadata, fileMetadata.ToString());
                        }
                    });
                getFileMetadataPromises.Add(func());
            }

            await Task.WhenAll(getFileMetadataPromises.ToArray());

            List<Task> tagPromises = new List<Task>(fileMetadatas.Count);

            foreach (KeyValuePair<int, string> keyValuePair in fileMetadatas)
            {
                int fileId = keyValuePair.Key;
                Func<Task> func = (async () =>
                {
                    await Task.Delay(random.NextTimeSpan(delay));
                    string fileMetadata = fileMetadatas[fileId];
                });
                tagPromises.Add(func());
            }

            await Task.WhenAll(tagPromises);

            // sort the fileMetadatas according to fileIds.
            List<string> results = new List<string>(fileMetadatas.Count);
            for (int i = 0; i < numItems; i++)
            {
                string metadata;
                if (fileMetadatas.TryGetValue(i, out metadata))
                {
                    results.Add(metadata);
                }
            }

            if (numItems != results.Count)
            {
                //throw new OrleansException(String.Format("numItems != results.Count, {0} != {1}", numItems, results.Count));
            }

        }
Пример #24
0
        private static Task<bool>[] InsertAndReadStreamsAndCheckMatch(RelationalStorageForTesting sut, int streamSize, int countOfStreams, CancellationToken cancellationToken)
        {
            //Stream in and steam out three binary streams in parallel.
            var streamChecks = new Task<bool>[countOfStreams];
            var sr = new SafeRandom();
            for(int i = 0; i < countOfStreams; ++i)
            {
                int streamId = i;
                streamChecks[i] = Task.Run(async () =>
                {
                    var rb = new byte[streamSize];
                    sr.NextBytes(rb);
                    await InsertIntoDatabaseUsingStream(sut, streamId, rb, cancellationToken);
                    var dataStreamFromTheDb = await ReadFromDatabaseUsingAsyncStream(sut, streamId, cancellationToken);
                    return dataStreamFromTheDb.StreamData.SequenceEqual(rb);
                });
            }

            return streamChecks;
        }