/// <summary>
 /// Event handler called when an environment change is to be applied to the role.
 /// Determines whether or not the role instance must be recycled.
 /// </summary>
 /// <param name="sender">The sender.</param>
 /// <param name="e">The list of changed environment values.</param>
 private void RoleEnvironmentChanging(object sender, RoleEnvironmentChangingEventArgs e)
 {
     // If Azure should recycle the role, e.Cancel should be set to true.
     // If the changes are ones we can handle without a recycle, we set it to false.
     e.Cancel = this.RecycleConfiguration(e.Changes);
     Trace.WriteLine("WebRole environment change - role instance recycling: " + e.Cancel.ToString());
 }

 private void RoleEnvironmentChanging(object sender, RoleEnvironmentChangingEventArgs e)
 {
     // If a configuration setting is changing
     if (e.Changes.Any(change => change is RoleEnvironmentConfigurationSettingChange))
         // set e.Cancel to true to restart this role instance
         e.Cancel = true;
 }

 private static void RoleEnvironmentChanging(object sender, RoleEnvironmentChangingEventArgs e)
 {
     if (e.Changes.Any(change => change is RoleEnvironmentConfigurationSettingChange))
     {
         e.Cancel = true;
     }
 }

        private static void RoleEnvironmentChanging(object sender, RoleEnvironmentChangingEventArgs e)
        {
            if (!e.Changes.Any(change => change is RoleEnvironmentConfigurationSettingChange)) return;

            Trace.WriteLine("Working", "Environment Change: " + e.Changes.ToList());
            e.Cancel = true;
        }

        //Event Handler
        public void RoleEnvironmentChanging(object sender, RoleEnvironmentChangingEventArgs e)
        {
            var changes = from ch in e.Changes.OfType<RoleEnvironmentTopologyChange>()
                          select ch;
            if (changes.Any())
            {
                const string semaphoreName = "SemaphoreShutDown";
                Semaphore sem = null;

                // Attempt to open the named semaphore.
                try
                {
                    sem = Semaphore.OpenExisting(semaphoreName);
                }
                catch (WaitHandleCannotBeOpenedException)
                {
                    return;
                }
                sem.Release(1);

                //Note this may be superfulous, as this event may be running on a non-blocking thread.  To be investigated.
                //If a blocking thread, this gives some time for IIS to complete its shutdown, based on the semaphore release
                //above.  
                Thread.Sleep(20000);
            }
        }

 private void RoleEnvironmentChanging(object sender, RoleEnvironmentChangingEventArgs e)
 {
     //Are any of the environment changes a configuration setting change? If so, cancel the event and restart the role
     if (e.Changes.Any(change => change is RoleEnvironmentConfigurationSettingChange))
     {
         e.Cancel = true;
     }
 }

 private void RoleEnvironmentChanging(object sender, RoleEnvironmentChangingEventArgs e)
 {
     e.Cancel = false; // don't restart for configuration changes
     /*if (e.Changes.Any(change => change is RoleEnvironmentConfigurationSettingChange))
     {
         e.Cancel = true;
     }*/
 }

 static void RoleEnvironment_Changing(object sender, RoleEnvironmentChangingEventArgs e)
 {
     if (e.Changes.OfType<RoleEnvironmentConfigurationSettingChange>().Count() > 0)
     {
         // Cancel the changing event to force role instance restart
         //e.Cancel = true;
     }
 }

 private void RoleEnvironmentChanging(object sender, RoleEnvironmentChangingEventArgs e)
 {
     // for any configuration setting change except EnableTableStorageTraceListener
     if (e.Changes.OfType<RoleEnvironmentConfigurationSettingChange>().Any(change => change.ConfigurationSettingName != "EnableTableStorageTraceListener"))
     {
         // Set e.Cancel to true to restart this role instance
         e.Cancel = true;
     }
 }

        static void RoleEnvironmentChanging(object sender, RoleEnvironmentChangingEventArgs e)
        {
            var i = 1;
            foreach (var c in e.Changes)
                Trace.WriteLine(string.Format("RoleEnvironmentChanging: #{0} Type={1} Change={2}", i++, c.GetType().FullName, c));

            if (e.Changes.Any(change => change is RoleEnvironmentConfigurationSettingChange))
                e.Cancel = true;
        }

 private void HandleRoleEnvironmentChanging(object sender, RoleEnvironmentChangingEventArgs e)
 {
     foreach(var c in e.Changes.OfType<RoleEnvironmentTopologyChange>())
     {
         if (c.RoleName.Equals(AzureConstants.StoreWorkerRoleName))
         {
             Trace.TraceInformation("BrightstarCluster: Received RoleEnvironmentTopologyChange event. Updating store worker client list");
             UpdateClientList();
         }
     }
 }

        static void OnRoleEnvironmentChanging(object sender, RoleEnvironmentChangingEventArgs e)
        {
            // we restart all workers if the configuration changed (e.g. the storage account)
            // for now.

            // We do not request a recycle if only the topology changed,
            // e.g. if some instances have been removed or added.
            var configChanges = e.Changes.OfType<RoleEnvironmentConfigurationSettingChange>();

            if(configChanges.Any())
            {
                RoleEnvironment.RequestRecycle();
            }
        }

        private static void RoleEnvironmentChanging(object sender, RoleEnvironmentChangingEventArgs e)
        {
            int i = 1;
            foreach (var c in e.Changes)
            {
                Trace.WriteLine(string.Format("RoleEnvironmentChanging: #{0} Type={1} Change={2}", i++, c.GetType().FullName, c));
            }

            // If a configuration setting is changing);
            if (e.Changes.Any((RoleEnvironmentChange change) => change is RoleEnvironmentConfigurationSettingChange))
            {
                // Set e.Cancel to true to restart this role instance
                e.Cancel = true;
            }
        }

        void RoleEnvironment_Changing(object sender, RoleEnvironmentChangingEventArgs e)
        {
            Trace.TraceInformation("Change notification");

            if (e.Changes.OfType<RoleEnvironmentConfigurationSettingChange>()
                .Any(c => !string.Equals(c.ConfigurationSettingName, MvcApplication.AzureLoggingVerbositySettingName, StringComparison.Ordinal)))
            {
                Trace.TraceInformation("Cancelling instance");
                e.Cancel = true;
            }
            else
            {
                Trace.TraceInformation("Handling change without recycle");
            }
        }

 private void OnChanging(object sender, RoleEnvironmentChangingEventArgs e)
 {
     foreach (var change in e.Changes)
     {
         var configChange = change as RoleEnvironmentConfigurationSettingChange;
         if (configChange != null)
         {
             if (configChange.ConfigurationSettingName == "DatabaseConnectionString")
             {
                 // Our database connectionstring changed.
                 // Maybe we need to restart the instance to make sure our cached objects no longer use the previous value.
                 e.Cancel = true;
             }
         }
     }
 }

        private void RoleEnvironmentOnChanging(object sender, RoleEnvironmentChangingEventArgs roleEnvironmentChangingEventArgs)
        {
            // In order to handle changing configuration
            // this can be avoided if the config is not "singleton" but it is recreated via this event
            // https://msdn.microsoft.com/en-us/library/azure/gg432963.aspx
            // https://alexandrebrisebois.wordpress.com/2013/09/29/handling-cloud-service-role-configuration-changes-in-windows-azure/

            var configurationChanges = roleEnvironmentChangingEventArgs.Changes
                                    .OfType<RoleEnvironmentConfigurationSettingChange>()
                                    .ToList();

            if (!configurationChanges.Any())
            {
                return;
            }

            // TODO for specific settings which are uesd to instantiate any cached objects
            //if(configurationChanges.Any(c => c.ConfigurationSettingName == "StorageAccount"))
            roleEnvironmentChangingEventArgs.Cancel = true;
        }

        private void RoleEnvironment_Changing(object sender, RoleEnvironmentChangingEventArgs e)
        {
            var changedSettings = e.Changes.OfType<RoleEnvironmentConfigurationSettingChange>()
                                            .Select(c => c.ConfigurationSettingName).ToList();

            Trace.TraceInformation("Configuration Changing notification. Settings being changed: "
                + string.Join(", ", changedSettings));

            if (changedSettings
                .Any(settingName => !string.Equals(settingName, CustomSettingName, StringComparison.Ordinal)))
            {
                Trace.TraceInformation("Cancelling dynamic configuration change (restarting).");

                // Setting this to true will restart the role gracefully. If Cancel is not set to true,
                // and the change is not handled by the application, then the application will not use
                // the new value until it is restarted (either manually or for some other reason).
                e.Cancel = true;
            }
            else
            {
                Trace.TraceInformation("Handling configuration change without restarting.");
            }
        }

        private static void RoleEnvironmentChanging(object sender, RoleEnvironmentChangingEventArgs e)
        {
            Boolean recycle = false;
            foreach (RoleEnvironmentChange change in e.Changes)
            {
                RoleEnvironmentTopologyChange topologyChange = change as RoleEnvironmentTopologyChange;
                if (topologyChange != null)
                {
                    String roleName = topologyChange.RoleName;
                    ReadOnlyCollection<RoleInstance> oldInstances = RoleEnvironment.Roles[roleName].Instances;
                }
                RoleEnvironmentConfigurationSettingChange settingChange = change as RoleEnvironmentConfigurationSettingChange;
                if (settingChange != null)
                {
                    String settingName = settingChange.ConfigurationSettingName;
                    String oldValue = RoleEnvironment.GetConfigurationSettingValue(settingName);
                    recycle |= settingName == "SettingRequiringRecycle";
                }
            }

            // Recycle when e.Cancel = true;
            e.Cancel = recycle;
        }

 /// <summary>
 /// Force restart of the instance.
 /// </summary>
 /// <param name="sender"></param>
 /// <param name="e"></param>
 void OnRoleEnvironmentChanging(object sender, RoleEnvironmentChangingEventArgs e)
 {
     if (e.Changes.Any(o => o is RoleEnvironmentChange))
         e.Cancel = true;
 }

        private static void RoleEnvironmentChanging(object sender, RoleEnvironmentChangingEventArgs e)
        {
            Trace.TraceInformation("RoleEnvironmentChanging Event Fired");

            var changes = e.Changes
                           .OfType<RoleEnvironmentConfigurationSettingChange>()
                           .ToList();

            if (!changes.Any())
            {
                return;
            }

            e.Cancel = true; // Instruct server to reboot on change (if not canceled below)

            // TODO: Implement (for now just repboot server)
            //// Service Bus Connection Strings Updated
            //if (changes.Any(c => c.ConfigurationSettingName == ServiceBus.FrontendServiceBusConnectionStringName))
            //{
            //    e.Cancel = false; // Cancel reboot of server
            //}
            //if (changes.Any(c => c.ConfigurationSettingName == ServiceBus.WorkerServiceBusConnectionStringName))
            //{
            //    e.Cancel = false; // Cancel reboot of server
            //}
        }