CloudWatchMonitor.MonitorService.Run C# (CSharp) Метод

        public void Run()
        {
            Info("CloudWatch Monitor starting");

            // Default monitor period is 1 minute
            int monitorPeriodInMinutes = 1;

            try
            {
                Info("Reading configuration");

                monitorPeriodInMinutes = ReadInt("MonitorPeriodInMinutes", 1);

                // Validate min/max values
                if (monitorPeriodInMinutes < 1)
                    throw new Exception("MonitorPeriodInMinutes must be greater than or equal to 1");
                Info("MonitorPeriodInMinutes: {0}", monitorPeriodInMinutes);

                _isSubmitDiskSpaceAvailable = ReadBoolean("SubmitDiskSpaceAvailable", true);
                Info("SubmitDiskSpaceAvailable: {0}", _isSubmitDiskSpaceAvailable);

                _isSubmitDiskSpaceUsed = ReadBoolean("SubmitDiskSpaceUsed", true);
                Info("SubmitDiskSpaceUsed: {0}", _isSubmitDiskSpaceUsed);

                _isSubmitDiskSpaceUtilization = ReadBoolean("SubmitDiskSpaceUtilization", true);
                Info("SubmitDiskSpaceUtilization: {0}", _isSubmitDiskSpaceUtilization);

                _isSubmitMemoryAvailable = ReadBoolean("SubmitMemoryAvailable", true);
                Info("SubmitMemoryAvailable: {0}", _isSubmitMemoryAvailable);

                _isSubmitMemoryUsed = ReadBoolean("SubmitMemoryUsed", true);
                Info("SubmitMemoryUsed: {0}", _isSubmitMemoryUsed);

                _isSubmitMemoryUtilization = ReadBoolean("SubmitMemoryUtilization", true);
                Info("SubmitMemoryUtilization: {0}", _isSubmitMemoryUtilization);

                _isSubmitPhysicalMemoryAvailable = ReadBoolean("SubmitPhysicalMemoryAvailable", true);
                Info("SubmitPhysicalMemoryAvailable: {0}", _isSubmitPhysicalMemoryAvailable);

                _isSubmitPhysicalMemoryUsed = ReadBoolean("SubmitPhysicalMemoryUsed", true);
                Info("SubmitPhysicalMemoryUsed: {0}", _isSubmitPhysicalMemoryUsed);

                _isSubmitPhysicalMemoryUtilization = ReadBoolean("SubmitPhysicalMemoryUtilization", true);
                Info("SubmitPhysicalMemoryUtilization: {0}", _isSubmitPhysicalMemoryUtilization);

                _isSubmitVirtualMemoryAvailable = ReadBoolean("SubmitVirtualMemoryAvailable", true);
                Info("SubmitVirtualMemoryAvailable: {0}", _isSubmitVirtualMemoryAvailable);

                _isSubmitVirtualMemoryUsed = ReadBoolean("SubmitVirtualMemoryUsed", true);
                Info("SubmitVirtualMemoryUsed: {0}", _isSubmitVirtualMemoryUsed);

                _isSubmitVirtualMemoryUtilization = ReadBoolean("SubmitVirtualMemoryUtilization", true);
                Info("SubmitVirtualMemoryUtilization: {0}", _isSubmitVirtualMemoryUtilization);

                _includeDrives = ReadStringList("IncludeDrives", null);
                if (_includeDrives != null)
                    Info("IncludeDrives: {0}", String.Join(",", _includeDrives));
                else
                    Info("IncludeDrives: All drives");

                _instanceId = ReadString("InstanceId", null);
                if (!String.IsNullOrEmpty(_instanceId))
                    Info("Instance ID: {0}", _instanceId);

                _regionName = ReadString("AWSRegion", null);
                if (!String.IsNullOrEmpty(_regionName))
                    Info("Region: {0}", _regionName);
            }
            catch (Exception e)
            {
                Error(e.Message);
                if (!Environment.UserInteractive)
                    this.Stop(); // Tell the service to stop
                return;
            }

            if (!_isSubmitDiskSpaceAvailable &&
                !_isSubmitDiskSpaceUsed &&
                !_isSubmitDiskSpaceUtilization &&
                !_isSubmitMemoryAvailable &&
                !_isSubmitMemoryUsed &&
                !_isSubmitMemoryUtilization &&
                !_isSubmitPhysicalMemoryAvailable &&
                !_isSubmitPhysicalMemoryUsed &&
                !_isSubmitPhysicalMemoryUtilization &&
                !_isSubmitVirtualMemoryAvailable &&
                !_isSubmitVirtualMemoryUsed &&
                !_isSubmitVirtualMemoryUtilization)
            {
                Error("No data is selected to submit.");
                if (!Environment.UserInteractive)
                    this.Stop(); // Tell the service to stop
                return;
            }

            while (true)
            {
                DateTime updateBegin = DateTime.Now;

                try
                {
                    UpdateMetrics();
                }
                catch (Exception e)
                {
                    Error("Error submitting metrics: {0}", e.Message);

                    // Ignore the error and continue
                }

                DateTime updateEnd = DateTime.Now;
                TimeSpan updateDiff = (updateEnd - updateBegin);

                TimeSpan baseTimeSpan = TimeSpan.FromMinutes(monitorPeriodInMinutes);

                TimeSpan timeToWait = (baseTimeSpan - updateDiff);
                if (timeToWait.TotalMilliseconds < 50)
                    timeToWait = TimeSpan.FromMilliseconds(50);

                // This event gives us our pause along with
                // our signal to shut down.  If the signal
                // arrives, then we shutdown, otherwise
                // we've just paused the desired amount.
                if (_evStop.WaitOne(timeToWait, false))
                    break;
            }

            Info("CloudWatch Monitor shutting down");
        }

        /// <summary>
        ///     The main entry point for the application.
        /// </summary>
        private static void Main(string[] args)
        {
            var service = new MonitorService();

            if (Environment.UserInteractive)
            {
                string parameter = string.Concat(args);
                switch (parameter)
                {
                    case "-i":
                        try
                        {
                            Console.WriteLine("Installing service...");
                            ManagedInstallerClass.InstallHelper(new[] {Assembly.GetExecutingAssembly().Location});
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine("Error installing service: {0}", e.Message);
                        }
                        return;

                    case "-u":
                        try
                        {
                            Console.WriteLine("Uninstalling service...");
                            ManagedInstallerClass.InstallHelper(new[] {"/u", Assembly.GetExecutingAssembly().Location});
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine("Error uninstalling service: {0}", e.Message);
                        }
                        return;

                    case "-a":
                        try
                        {
                            Console.WriteLine("Creating AWS alarms...");
                            service.CreateAlarms();
                        }
                        catch (Exception e)
                        {
                            Console.WriteLine("Error creating alarms: {0}", e.Message);
                        }
                        return;
                }

                service.Run();
                return;
            }

            var servicesToRun = new ServiceBase[]
            {
                service
            };
            ServiceBase.Run(servicesToRun);
        }