xenadmin/XenAdmin/Wlb/WlbPoolConfiguration.cs

/* Copyright (c) Citrix Systems Inc. 
 * All rights reserved. 
 * 
 * Redistribution and use in source and binary forms, 
 * with or without modification, are permitted provided 
 * that the following conditions are met: 
 * 
 * *   Redistributions of source code must retain the above 
 *     copyright notice, this list of conditions and the 
 *     following disclaimer. 
 * *   Redistributions in binary form must reproduce the above 
 *     copyright notice, this list of conditions and the 
 *     following disclaimer in the documentation and/or other 
 *     materials provided with the distribution. 
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 
 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, 
 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE 
 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR 
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, 
 * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR 
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
 * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING 
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 
 * SUCH DAMAGE.
 */

using System;
using System.Collections.Generic;
using System.Text;

using XenAPI;

namespace XenAdmin.Wlb
{

#region Public Enums

    public enum WlbPoolPerformanceMode : int
    {
        MaximizePerformance = 0,
        MaximizeDensity = 1
    }

    public enum WlbPoolAutoBalanceSeverity
    {
        Low,
        Medium,
        High,
        Critical
    }

    public enum WlbPoolAutoBalanceAggressiveness
    {
        Low,
        Medium,
        High
    }

    public enum WlbAuditTrailLogGranularity
    {
        Minimum,
        Medium,
        Maximum
    }

#endregion

    public class WlbPoolConfiguration : WlbConfigurationBase
    {

#region Private Constants

        private const int WlbVersion_Major_MNR = 2;
        private const int WlbVersion_Minor_MNR = 0;
        private const int WlbVersion_Major_Cowley = 2;
        private const int WlbVersion_Minor_Cowley = 1;
        private const int WlbVersion_Major_Boston = 6;
        private const int WlbVersion_Minor_Boston = 0;
        private const int WlbVersion_Major_Tampa = 6;
        private const int WlbVersion_Minor_Tampa = 1;
        private const int WlbVersion_Major_Creedence = 6;
        private const int WlbVersion_Minor_Creedence = 5;

#endregion

#region Private Members

        // these are the factors used to calculate the indirectly set values
        // initial values are defaults in case we don't get them from the wlb server
        private double _cpuHighThresholdFactor = .85;
        private double _cpuMediumThresholdFactor = .50;
        private double _cpuLowThresholdFactor = .15;
        private double _memoryHighThresholdFactor = 1.25;
        private double _memoryMediumThresholdFactor = 10.00;
        private double _memoryLowThresholdFactor = 20.00;
        private double _networkReadHighThresholdFactor = .85;
        private double _networkReadMediumThresholdFactor = .50;
        private double _networkReadLowThresholdFactor = .15;
        private double _networkWriteHighThresholdFactor = .85;
        private double _networkWriteMediumThresholdFactor = .50;
        private double _networkWriteLowThresholdFactor = .15;
        private double _diskReadHighThresholdFactor = .85;
        private double _diskReadMediumThresholdFactor = .50;
        private double _diskReadLowThresholdFactor = .15;
        private double _diskWriteHighThresholdFactor = .85;
        private double _diskWriteMediumThresholdFactor = .50;
        private double _diskWriteLowThresholdFactor = .15;

        private double _cpuMediumWeightFactor = .60;
        private double _cpuLowWeightFactor = .30;
        private double _memoryMediumWeightFactor = .60;
        private double _memoryLowWeightFactor = .30;
        private double _networkReadMediumWeightFactor = .60;
        private double _networkReadLowWeightFactor = .30;
        private double _networkWriteMediumWeightFactor = .60;
        private double _networkWriteLowWeightFactor = .30;
        private double _diskReadMediumWeightFactor = .60;
        private double _diskReadLowWeightFactor = .30;
        private double _diskWriteMediumWeightFactor = .60;
        private double _diskWriteLowWeightFactor = .30;

        private double _metricGroomingPeriod = 0; //0 indicates grroming disabled (SQLExpress)

        private WlbHostConfigurations _hostConfigurations;
        private WlbScheduledTasks _scheduledTasks;
#endregion

#region Constructor
        public WlbPoolConfiguration(Dictionary<string, string> configuration)
        {
            if (null != configuration)
            {
                base.Configuration = configuration;
                PopulateKeyValues();
                _hostConfigurations = new WlbHostConfigurations(base.Configuration);
                _scheduledTasks = new WlbScheduledTasks(base.Configuration);
            }
            else
            {
                throw new Exception("WLBPoolConfiguration is null");
            }
        }

#endregion

#region Private Methods

        private void PopulateKeyValues()
        {
            _cpuHighThresholdFactor = GetConfigValueDouble("CpuHighThresholdFactor", _cpuHighThresholdFactor);
            _cpuMediumThresholdFactor = GetConfigValueDouble("CpuMediumThresholdFactor", _cpuMediumThresholdFactor);
            _cpuLowThresholdFactor = GetConfigValueDouble("CpuLowThresholdFactor", _cpuLowThresholdFactor);
            _memoryHighThresholdFactor = GetConfigValueDouble("MemoryHighThresholdFactor", _memoryHighThresholdFactor);
            _memoryMediumThresholdFactor = GetConfigValueDouble("MemoryMediumThresholdFactor", _memoryMediumThresholdFactor);
            _memoryLowThresholdFactor = GetConfigValueDouble("MemoryLowThresholdFactor", _memoryLowThresholdFactor);
            _networkReadHighThresholdFactor = GetConfigValueDouble("NetworkReadHighThresholdFactor", _networkReadHighThresholdFactor);
            _networkReadMediumThresholdFactor = GetConfigValueDouble("NetworkReadMediumThresholdFactor", _networkReadMediumThresholdFactor);
            _networkReadLowThresholdFactor = GetConfigValueDouble("NetworkReadLowThresholdFactor", _networkReadLowThresholdFactor);
            _networkWriteHighThresholdFactor = GetConfigValueDouble("networkWriteHighThresholdFactor", _networkWriteHighThresholdFactor);
            _networkWriteMediumThresholdFactor = GetConfigValueDouble("networkWriteMediumThresholdFactor", _networkWriteMediumThresholdFactor);
            _networkWriteLowThresholdFactor = GetConfigValueDouble("NetworkWriteLowThresholdFactor", _networkWriteLowThresholdFactor);
            _diskReadHighThresholdFactor = GetConfigValueDouble("DiskReadHighThresholdFactor", _diskReadHighThresholdFactor);
            _diskReadMediumThresholdFactor = GetConfigValueDouble("DiskReadMediumThresholdFactor", _diskReadMediumThresholdFactor);
            _diskReadLowThresholdFactor = GetConfigValueDouble("DiskReadLowThresholdFactor", _diskReadLowThresholdFactor);
            _diskWriteHighThresholdFactor = GetConfigValueDouble("DiskWriteHighThresholdFactor", _diskWriteHighThresholdFactor);
            _diskWriteMediumThresholdFactor = GetConfigValueDouble("DiskWriteMediumThresholdFactor", _diskWriteMediumThresholdFactor);
            _diskWriteLowThresholdFactor = GetConfigValueDouble("DiskWriteLowThresholdFactor", _diskWriteLowThresholdFactor);

            _cpuMediumWeightFactor = GetConfigValueDouble("CpuMediumWeightFactor", _cpuMediumWeightFactor);
            _cpuLowWeightFactor = GetConfigValueDouble("CpuLowWeightFactor", _cpuLowWeightFactor);
            _memoryMediumWeightFactor = GetConfigValueDouble("MemoryMediumWeightFactor", _memoryMediumWeightFactor);
            _memoryLowWeightFactor = GetConfigValueDouble("MemoryLowWeightFactor", _memoryLowWeightFactor);
            _networkReadMediumWeightFactor = GetConfigValueDouble("NetworkReadMediumWeightFactor", _networkReadMediumWeightFactor);
            _networkReadLowWeightFactor = GetConfigValueDouble("NetworkReadLowWeightFactor", _networkReadLowWeightFactor);
            _networkWriteMediumWeightFactor = GetConfigValueDouble("NetworkWriteMediumWeightFactor", _networkWriteMediumWeightFactor);
            _networkWriteLowWeightFactor = GetConfigValueDouble("NetworkWriteLowWeightFactor", _networkWriteLowWeightFactor);
            _diskReadMediumWeightFactor = GetConfigValueDouble("DiskReadMediumWeightFactor", _diskReadMediumWeightFactor);
            _diskReadLowWeightFactor = GetConfigValueDouble("DiskReadLowWeightFactor", _diskReadLowWeightFactor);
            _diskWriteMediumWeightFactor = GetConfigValueDouble("diskWriteMediumWeightFactor", _diskWriteMediumWeightFactor);
            _diskWriteLowWeightFactor = GetConfigValueDouble("DiskWriteLowWeightFactor", _diskWriteLowWeightFactor);
          }
#endregion

#region Properties

        public WlbPoolPerformanceMode PerformanceMode
        {
            get { return (WlbPoolPerformanceMode)GetConfigValueDouble("OptimizationMode"); }
            set
            {
                SetConfigValueDouble("OptimizationMode", (double)value);
            }
        }

        public bool OvercommitCPUs
        {
            get
            {
                if (this.PerformanceMode == WlbPoolPerformanceMode.MaximizeDensity)
                {
                    return GetConfigValueBool("OverCommitCpuInDensityMode");
                }
                else
                {
                    return GetConfigValueBool("OverCommitCpuInPerfMode");
                }
            }
            set
            {
                if (this.PerformanceMode == WlbPoolPerformanceMode.MaximizeDensity)
                {
                    SetConfigValueBool("OverCommitCpuInDensityMode", value);
                }
                else
                {
                    SetConfigValueBool("OverCommitCpuInPerfMode", value);
                }
            }
        }

        public int HostCpuThresholdCritical
        {
            get { return GetConfigValuePercent("HostCpuThresholdCritical"); }
            set 
            {
                SetConfigValuePercent("HostCpuThresholdCritical", value);
                SetConfigValuePercent("HostCpuThresholdHigh", (int)(value * _cpuHighThresholdFactor));
                SetConfigValuePercent("HostCpuThresholdMedium", (int)(value * _cpuMediumThresholdFactor));
                SetConfigValuePercent("HostCpuThresholdLow", (int)(value * _cpuLowThresholdFactor));
            }
        }

        public double HostMemoryThresholdCritical
        {
            get { return GetConfigValueDouble("HostMemoryThresholdCritical"); }
            set
            {
                SetConfigValueDouble("HostMemoryThresholdCritical", value);
                SetConfigValueDouble("HostMemoryThresholdHigh", value * _memoryHighThresholdFactor);
                SetConfigValueDouble("HostMemoryThresholdMedium", value * _memoryMediumThresholdFactor);
                SetConfigValueDouble("HostMemoryThresholdLow", value * _memoryLowThresholdFactor);
            }
        }

        public double HostNetworkReadThresholdCritical
        {
            get { return GetConfigValueDouble("HostPifReadThresholdCritical"); }
            set
            {
                SetConfigValueDouble("HostPifReadThresholdCritical", value);
                SetConfigValueDouble("HostPifReadThresholdHigh", value * _networkReadHighThresholdFactor);
                SetConfigValueDouble("HostPifReadThresholdMedium", value * _networkReadMediumThresholdFactor);
                SetConfigValueDouble("HostPifReadThresholdLow", value * _networkReadLowThresholdFactor);
            }
        }

        public double HostNetworkWriteThresholdCritical
        {
            get { return GetConfigValueDouble("HostPifWriteThresholdCritical"); }
            set
            {
                SetConfigValueDouble("HostPifWriteThresholdCritical", value);
                SetConfigValueDouble("HostPifWriteThresholdHigh", value * _networkWriteHighThresholdFactor);
                SetConfigValueDouble("HostPifWriteThresholdMedium", value * _networkWriteMediumThresholdFactor);
                SetConfigValueDouble("HostPifWriteThresholdLow", value * _networkWriteLowThresholdFactor);
            }
        }

        public double HostDiskReadThresholdCritical
        {
            get { return GetConfigValueDouble("HostPbdReadThresholdCritical"); }
            set
            { 
                SetConfigValueDouble("HostPbdReadThresholdCritical", value);
                SetConfigValueDouble("HostPbdReadThresholdHigh", value * _diskReadHighThresholdFactor);
                SetConfigValueDouble("HostPbdReadThresholdMedium", value * _diskReadMediumThresholdFactor);
                SetConfigValueDouble("HostPbdReadThresholdLow", value * _diskReadLowThresholdFactor);
            }
        }

        public double HostDiskWriteThresholdCritical
        {
            get { return GetConfigValueDouble("HostPbdWriteThresholdCritical"); }
            set 
            {
                SetConfigValueDouble("HostPbdWriteThresholdCritical", value);
                SetConfigValueDouble("HostPbdWriteThresholdHigh", value * _diskWriteHighThresholdFactor);
                SetConfigValueDouble("HostPbdWriteThresholdMedium", value * _diskWriteMediumThresholdFactor);
                SetConfigValueDouble("HostPbdWriteThresholdLow", value * _diskWriteLowThresholdFactor);
            }
        }

        public int VmCpuUtilizationWeightHigh
        {
            get { return GetConfigValuePercent("VmCpuUtilizationWeightHigh"); }
            set 
            {
                SetConfigValuePercent("VmCpuUtilizationWeightHigh", value);
                SetConfigValuePercent("VmCpuUtilizationWeightMedium", (int)(value * _cpuMediumWeightFactor));
                SetConfigValuePercent("VmCpuUtilizationWeightLow", (int)(value * _cpuLowWeightFactor));
            }
        }

        public int VmMemoryWeightHigh
        {
            get { return GetConfigValuePercent("VmMemoryWeightHigh"); }
            set
            {
                SetConfigValuePercent("VmMemoryWeightHigh", value);
                SetConfigValuePercent("VmMemoryWeightMedium", (int)(value * _memoryMediumWeightFactor));
                SetConfigValuePercent("VmMemoryWeightLow", (int)(value * _memoryLowWeightFactor));
            }
        }

        public int VmDiskReadWeightHigh
        {
            get { return GetConfigValuePercent("VmDiskReadWeightHigh"); }
            set
            {
                SetConfigValuePercent("VmDiskReadWeightHigh", value);
                SetConfigValuePercent("VmDiskReadWeightMedium", (int)(value * _diskReadMediumWeightFactor));
                SetConfigValuePercent("VmDiskReadWeightLow", (int)(value * _diskWriteLowWeightFactor));
            }
        }

        public int VmDiskWriteWeightHigh
        {
            get { return GetConfigValuePercent("VmDiskWriteWeightHigh"); }
            set
            {
                SetConfigValuePercent("VmDiskWriteWeightHigh", value);
                SetConfigValuePercent("VmDiskWriteWeightMedium", (int)(value * _diskWriteMediumWeightFactor));
                SetConfigValuePercent("VmDiskWriteWeightLow", (int)(value * _diskWriteLowWeightFactor));
            }
        }

        public int VmNetworkReadWeightHigh
        {
            get { return GetConfigValuePercent("VmNetworkReadWeightHigh"); }
            set
            {
                SetConfigValuePercent("VmNetworkReadWeightHigh", value);
                SetConfigValuePercent("VmNetworkReadWeightMedium", (int)(value * _networkReadMediumWeightFactor));
                SetConfigValuePercent("VmNetworkReadWeightLow", (int)(value * _networkReadLowWeightFactor));
            }
        }

        public int VmNetworkWriteWeightHigh
        {
            get { return GetConfigValuePercent("VmNetworkWriteWeightHigh"); }
            set
            {
                SetConfigValuePercent("VmNetworkWriteWeightHigh", value);
                SetConfigValuePercent("VmNetworkWriteWeightMedium", (int)(value * _networkWriteMediumWeightFactor));
                SetConfigValuePercent("VmNetworkWriteWeightLow", (int)(value* _networkWriteLowWeightFactor));
            }
        }

        // Removed from WLB Web Service in Tampa
        public double MetricGroomingPeriod
        {
            get { return GetConfigValueDouble("MetricGroomingPeriod", _metricGroomingPeriod); }
            set { SetConfigValueDouble("MetricGroomingPeriod", value); }
        }

        public bool CredentialsValid
        {
            get { return GetConfigValueBool("CredentialsValid", true); }
        }

        public double RecentMoveMinutes
        {
            get { return GetConfigValueDouble("RecentMoveMinutes"); }
            set { SetConfigValueDouble("RecentMoveMinutes", value); }
        }

        public bool SupportsAutoBalance
        {
            get { return IsMROrLater; }
        }

        public bool AutoBalanceEnabled
        {
            get { return GetConfigValueBool("AutoBalanceEnabled"); }
            set
            {
                if (IsMROrLater)
                {
                    SetConfigValueBool("AutoBalanceEnabled", value);
                }
            }
        }

        public double AutoBalancePollIntervals
        {
            get { return GetConfigValueDouble("AutoBalancePollIntervals"); }
            set
            {
                if (IsMROrLater)
                {
                    SetConfigValueDouble("AutoBalancePollIntervals", value);
                }
            }
        }

        public WlbPoolAutoBalanceSeverity AutoBalanceSeverity
        {
            get { return (WlbPoolAutoBalanceSeverity)Enum.Parse(typeof(WlbPoolAutoBalanceSeverity), GetConfigValueString("AutoBalanceSeverity")); }
            set
            {
                if (IsMROrLater)
                {
                    SetConfigValueString("AutoBalanceSeverity", value.ToString());
                }
            }
        }

        public WlbPoolAutoBalanceAggressiveness AutoBalanceAggressiveness
        {
            get { return (WlbPoolAutoBalanceAggressiveness)Enum.Parse(typeof(WlbPoolAutoBalanceAggressiveness), GetConfigValueString("AutoBalanceAggressiveness")); }
            set
            {
                if (IsMROrLater)
                {
                    SetConfigValueString("AutoBalanceAggressiveness", value.ToString());
                }
            }
        }

        public WlbAuditTrailLogGranularity PoolAuditGranularity
        {
            get { return (WlbAuditTrailLogGranularity)Enum.Parse(typeof(WlbAuditTrailLogGranularity), GetConfigValueString("PoolAuditLogGranularity")); }
            set
            {
                if (IsCreedenceOrLater)
                {
                    SetConfigValueString("PoolAuditLogGranularity", value.ToString());
                }
            }
        }

        public bool IsCreedenceOrLater
        {
            get { return ((this.WlbMajorVersion >= WlbVersion_Major_Creedence) && (this.WlbMinorVersion >= WlbVersion_Minor_Creedence)); }
        }

        public bool IsTampaOrLater
        {
            get { return ((this.WlbMajorVersion >= WlbVersion_Major_Tampa) && (this.WlbMinorVersion >= WlbVersion_Minor_Tampa)); }
        }

        public bool IsBostonOrLater
        {
            get { return (this.WlbMajorVersion >= WlbVersion_Major_Boston); }
        }

        public bool IsMROrLater
        {
            get
            {
                // WLB Boston and later have a nice WLB Version value to check.
                if (this.WlbMajorVersion != -1)
                {
                    return (this.WlbMajorVersion >= WlbVersion_Major_MNR);
                }
                //older version of WLB do not.
                else
                {
                    return (base.Configuration.ContainsKey("AutoBalanceAggressiveness"));
                }
            }
        }

        public int WlbMajorVersion
        {
            get
            {
                int majorVersion = -1;
                string versionString = GetConfigValueString("WlbVersion");
                if (!string.IsNullOrEmpty(versionString))
                {
                    int.TryParse(versionString.Split('.')[0], out majorVersion);
                }
                return majorVersion;
            }
        }

        public int WlbMinorVersion
        {
            get
            {
                int majorVersion = -1;
                string versionString = GetConfigValueString("WlbVersion");
                if (!string.IsNullOrEmpty(versionString))
                {
                    int.TryParse(versionString.Split('.')[1], out majorVersion);
                }
                return majorVersion;
            }
        }

        public bool PowerManagementEnabled
        {
            get {return GetConfigValueBool("PowerManagementEnabled");}
            set
            {
                if (IsMROrLater)
                {
                    SetConfigValueBool("PowerManagementEnabled", value);
                }
            }
        }

        public double PowerManagementPollIntervals
        {
            get { return GetConfigValueDouble("PowerManagementPollIntervals"); }
            set
            {
                if (IsMROrLater)
                {
                    SetConfigValueDouble("PowerManagementPollIntervals", value);
                }
            }
        }

        /* Not in use, removed from WLB web service in Tampa
        public bool ReportingUseRSServer
        {
            get { return GetConfigValueBool("ReportingUseRSServer"); }
            set { SetConfigValueBool("ReportingUseRSServer", value); }
        }
        */

        // Removed from WLB Web Service in Tampa
        public string ReportingSMTPServer
        {
            get { return GetConfigValueString("ReportingSMTPServer"); }
            set { SetConfigValueString("ReportingSMTPServer", value); }
        }

        public bool AutomateOptimizationMode
        {
            get { return GetConfigValueBool("EnableOptimizationModeSchedules"); }
            set 
            {
                if (IsMROrLater)
                {
                    SetConfigValueBool("EnableOptimizationModeSchedules", value);
                }
            }
        }

        public WlbHostConfigurations HostConfigurations
        {
            get { return _hostConfigurations; }
        }

        public WlbScheduledTasks ScheduledTasks
        {
            get { return _scheduledTasks; }
        }

#endregion

    }
}