public void TestMultipleEvents()
        {
            using (InterRoleCommunicationExtension ircExtension = new InterRoleCommunicationExtension(topicEndpoint, new InterRoleCommunicationSettings() { EnableCarbonCopy = true }))
            {
                var subscriber1 = new EventCountingSubscriber();
                ircExtension.Subscribe(subscriber1);

                int eventCount = 100;
                int waitAttemptCount = 0;

                for (int i = 0; i < eventCount; i++)
                {
                    ircExtension.Publish(new InterRoleCommunicationEvent(new RoleConfigurationSectionRefreshEvent(String.Format("Message #{0}", i))));
                }

                while (subscriber1.OnNextCount != eventCount)
                {
                    Thread.Sleep(ircExtension.Settings.EventWaitTimeout.Add(TimeSpan.FromSeconds(5)));
                    waitAttemptCount++;

                    if (waitAttemptCount > 10) break;
                }

                Assert.AreEqual<int>(eventCount, subscriber1.OnNextCount);
            }
        }
        public void TestSingleEventWithCompetingConsumers()
        {
            var ircSettings = new InterRoleCommunicationSettings() { UseCompetingConsumers = true, EventWaitTimeout = TimeSpan.FromSeconds(10) };

            using (InterRoleCommunicationExtension irc1 = new InterRoleCommunicationExtension(topicEndpoint, ircSettings))
            using (InterRoleCommunicationExtension irc2 = new InterRoleCommunicationExtension(topicEndpoint, ircSettings))
            using (InterRoleCommunicationExtension irc3 = new InterRoleCommunicationExtension(topicEndpoint, ircSettings))
            using (InterRoleCommunicationExtension irc4 = new InterRoleCommunicationExtension(topicEndpoint, ircSettings))
            {
                var subscriber1 = new EventCountingSubscriber();

                irc1.Subscribe(subscriber1);
                irc2.Subscribe(subscriber1);
                irc3.Subscribe(subscriber1);
                irc4.Subscribe(subscriber1);

                InterRoleCommunicationEvent ev = new InterRoleCommunicationEvent(new RoleGracefulRecycleEvent(typeof(TopicBasedInterRoleCommunicationTests).FullName));

                irc1.Publish(ev);
                irc1.Publish(ev);
                irc1.Publish(ev);

                Thread.Sleep(irc4.Settings.EventWaitTimeout.Add(TimeSpan.FromSeconds(5)));

                Assert.AreEqual<int>(3, subscriber1.OnNextCount);
            }
        }
        public void TestSingleEvent()
        {
            using (InterRoleCommunicationExtension ircExtension = new InterRoleCommunicationExtension(topicEndpoint, new InterRoleCommunicationSettings() { EnableCarbonCopy = true }))
            {
                var subscriber1 = new EventCountingSubscriber();
                ircExtension.Subscribe(subscriber1);

                InterRoleCommunicationEvent ev = new InterRoleCommunicationEvent(new RoleGracefulRecycleEvent(typeof(TopicBasedInterRoleCommunicationTests).FullName));
                ircExtension.Publish(ev);

                Thread.Sleep(ircExtension.Settings.EventWaitTimeout.Add(TimeSpan.FromSeconds(5)));

                Assert.AreEqual<int>(1, subscriber1.OnNextCount);
            }
        }
        public void TestSingleEventWithNetworkFaultSimulation()
        {
            try
            {
                using (InterRoleCommunicationExtension ircExtension = new InterRoleCommunicationExtension(topicEndpoint, new InterRoleCommunicationSettings() { EnableCarbonCopy = true, EnableAsyncPublish = false, EventWaitTimeout = TimeSpan.FromSeconds(3) }))
                {
                    bool retryOccurred = false;

                    ircExtension.Settings.RetryPolicy.RetryOccurred += (currentRetryCount, ex, delay) =>
                    {
                        retryOccurred = true;
                        NetworkUtility.EnableNetworkAdapter();
                    };

                    var subscriber1 = new EventCountingSubscriber();
                    ircExtension.Subscribe(subscriber1);

                    NetworkUtility.DisableNetworkAdapter();

                    InterRoleCommunicationEvent ev = new InterRoleCommunicationEvent(new RoleGracefulRecycleEvent(typeof(TopicBasedInterRoleCommunicationTests).FullName));
                    ircExtension.Publish(ev);

                    while (subscriber1.OnNextCount == 0)
                    {
                        Thread.Sleep(ircExtension.Settings.EventWaitTimeout.Add(TimeSpan.FromSeconds(5)));
                    }

                    Assert.IsTrue(retryOccurred, "A retry condition does not seem to have occurred.");
                    Assert.AreEqual<int>(1, subscriber1.OnNextCount);
                }
            }
            finally
            {
                NetworkUtility.EnableNetworkAdapter();
            }
        }
Exemplo n.º 5
0
        /// <summary>
        /// Called by Windows Azure service runtime to initialize the role instance.
        /// </summary>
        /// <returns>Return true if initialization succeeds, otherwise returns false.</returns>
        public override bool OnStart()
        {
            try
            {
                StartDiagnosticMonitor();

                ServicePointManager.DefaultConnectionLimit = Environment.ProcessorCount * 12;
                ServicePointManager.UseNagleAlgorithm      = false;

                TraceManager.WorkerRoleComponent.TraceIn();

                var serviceBusSettings = ConfigurationManager.GetSection(ServiceBusConfigurationSettings.SectionName) as ServiceBusConfigurationSettings;

                var pubsubType           = ConfigurationManager.AppSettings[CommonConsts.ConfigSettingPubSubType];
                var storageAccountName   = ConfigurationManager.AppSettings[CommonConsts.ConfigSettingStorageAccount];
                var storageAccountKey    = ConfigurationManager.AppSettings[CommonConsts.ConfigSettingStorageAccountKey];
                var testResultsTableName = ConfigurationManager.AppSettings[CommonConsts.ConfigSettingTestResultsTableName];
                var testRunsTableName    = ConfigurationManager.AppSettings[CommonConsts.ConfigSettingTestRunsTableName];

                if (pubsubType.Equals(CommonConsts.ConfigSettingPubSubTypeValueTopic))
                {
                    var topicEndpoint = serviceBusSettings.Endpoints.Get(CommonConsts.TopicServiceBusEndpointName);

                    var ircComponent = new InterRoleCommunicationExtension(topicEndpoint);
                    ircComponent.Settings.RetryPolicy.RetryOccurred += (currentRetryCount, ex, delay) =>
                    {
                        TraceManager.WorkerRoleComponent.TraceWarning("******> RETRY LOGIC KICKED IN <******");
                        TraceManager.WorkerRoleComponent.TraceError(ex);
                    };

                    this.interRoleCommunicator = ircComponent;
                }
                else
                {
                    var topicEndpoint = serviceBusSettings.Endpoints.Get(CommonConsts.EventRelayServiceBusEndpointName);

                    this.interRoleCommunicator = new InterRoleEventRelayCommunicationExtension(topicEndpoint);
                }

                int  instanceIndex   = CommonFuncs.GetRoleInstanceIndex(RoleEnvironment.CurrentRoleInstance.Id);
                bool isFirstInstance = (instanceIndex == 0);

                if (isFirstInstance)
                {
                    var creds          = new StorageCredentialsAccountAndKey(storageAccountName, storageAccountKey);
                    var storageAccount = new CloudStorageAccount(creds, true);

                    resultTableStorage = storageAccount.CreateCloudTableClient();
                    resultTableStorage.CreateTableIfNotExist(testResultsTableName);
                    resultTableStorage.CreateTableIfNotExist(testRunsTableName);
                    resultTableStorage.RetryPolicy = RetryPolicies.Retry(RetryPolicies.DefaultClientRetryCount, TimeSpan.FromMilliseconds(100));

                    var ackSubscriber        = new UnicastACKSubscriber(interRoleCommunicator, resultTableStorage, testResultsTableName);
                    var startEventSubscriber = new TestRunStartEventSubscriber(interRoleCommunicator, resultTableStorage, testRunsTableName, ackSubscriber);

                    // Register the subscriber for receiving inter-role communication events.
                    this.activeSubscription.Add(this.interRoleCommunicator.Subscribe(ackSubscriber));
                    this.activeSubscription.Add(this.interRoleCommunicator.Subscribe(startEventSubscriber));
                }
                else
                {
                    var ircEventSubscriber = new MulticastEventSubscriber(instanceIndex.ToString(), interRoleCommunicator);

                    // Register the subscriber for receiving inter-role communication events.
                    this.activeSubscription.Add(this.interRoleCommunicator.Subscribe(ircEventSubscriber));
                }
            }
            catch (Exception ex)
            {
                TraceManager.WorkerRoleComponent.TraceError(ex);

                RoleEnvironment.RequestRecycle();
                return(false);
            }

            return(true);
        }