protected override List <CheckGroup> GenerateChecks(Pool_patch patch)
        {
            var groups = new List <CheckGroup>();

            //XenCenter version check (if any of the selected server version is not the latest)
            var latestCrVersion = Updates.XenServerVersions.FindAll(item => item.LatestCr).OrderByDescending(v => v.Version).FirstOrDefault();

            if (latestCrVersion != null &&
                SelectedServers.Any(host => new Version(Helpers.HostProductVersion(host)) < latestCrVersion.Version))
            {
                groups.Add(new CheckGroup(Messages.CHECKING_XENCENTER_VERSION, new List <Check> {
                    new XenCenterVersionCheck(null)
                }));
            }

            //HostMaintenanceModeCheck checks
            var livenessChecks = new List <Check>();

            foreach (Host host in SelectedServers)
            {
                livenessChecks.Add(new HostMaintenanceModeCheck(host));
            }

            groups.Add(new CheckGroup(Messages.CHECKING_HOST_LIVENESS_STATUS, livenessChecks));

            //HA checks
            var haChecks = new List <Check>();

            foreach (Pool pool in SelectedPools)
            {
                Host host = pool.Connection.Resolve(pool.master);

                if (host == null)
                {
                    continue;
                }

                haChecks.Add(new HAOffCheck(host));
            }
            groups.Add(new CheckGroup(Messages.CHECKING_HA_STATUS, haChecks));

            //Checking can evacuate host
            var evacuateChecks = new List <Check>();

            foreach (Host host in SelectedServers)
            {
                evacuateChecks.Add(new AssertCanEvacuateUpgradeCheck(host));
            }

            groups.Add(new CheckGroup(Messages.CHECKING_CANEVACUATE_STATUS, evacuateChecks));

            //PBDsPluggedCheck
            var pbdChecks = new List <Check>();

            foreach (Host host in SelectedServers)
            {
                pbdChecks.Add(new PBDsPluggedCheck(host));
            }
            groups.Add(new CheckGroup(Messages.CHECKING_STORAGE_CONNECTIONS_STATUS, pbdChecks));


            //HotfixesCheck required for MNR, Cowley, Boston and Sanibel
            var hotfixChecks = new List <Check>();

            foreach (var host in SelectedServers)
            {
                if (new HotfixFactory().IsHotfixRequired(host) && !ManualUpgrade)
                {
                    hotfixChecks.Add(new HostHasHotfixCheck(host));
                }
            }
            if (hotfixChecks.Count > 0)
            {
                groups.Add(new CheckGroup(Messages.CHECKING_UPGRADE_HOTFIX_STATUS, hotfixChecks));
            }


            //iSL (StorageLink) check - CA-223486: only for pre-Creedence
            var preCreedenceServers = SelectedServers.Where(h => !Helpers.CreedenceOrGreater(h)).ToList();

            if (preCreedenceServers.Any())
            {
                var srLinkChecks = new List <Check>();
                foreach (Host host in preCreedenceServers)
                {
                    srLinkChecks.Add(new HostHasUnsupportedStorageLinkSRCheck(host));
                }
                groups.Add(new CheckGroup(Messages.CHECKING_STORAGELINK_STATUS, srLinkChecks));
            }

            //SafeToUpgradeCheck - in automatic mode only
            if (!ManualUpgrade)
            {
                var upgradeChecks = new List <Check>();
                foreach (Host host in SelectedServers)
                {
                    upgradeChecks.Add(new SafeToUpgradeCheck(host));
                }

                groups.Add(new CheckGroup(Messages.CHECKING_SAFE_TO_UPGRADE, upgradeChecks));
            }

            return(groups);
        }
예제 #2
0
        protected override List <KeyValuePair <string, List <Check> > > GenerateChecks(Pool_patch patch)
        {
            List <KeyValuePair <string, List <Check> > > checks = new List <KeyValuePair <string, List <Check> > >();

            //HostMaintenanceModeCheck checks
            checks.Add(new KeyValuePair <string, List <Check> >(Messages.CHECKING_HOST_LIVENESS_STATUS, new List <Check>()));
            List <Check> checkGroup = checks[checks.Count - 1].Value;

            foreach (Host host in SelectedServers)
            {
                checkGroup.Add(new HostMaintenanceModeCheck(host));
            }

            //HA checks
            checks.Add(new KeyValuePair <string, List <Check> >(Messages.CHECKING_HA_STATUS, new List <Check>()));
            checkGroup = checks[checks.Count - 1].Value;
            foreach (Pool pool in SelectedPools)
            {
                Host host = pool.Connection.Resolve(pool.master);

                if (host == null)
                {
                    continue;
                }

                checkGroup.Add(new HAOffCheck(host));
            }

            //Checking can evacuate host
            checks.Add(new KeyValuePair <string, List <Check> >(Messages.CHECKING_CANEVACUATE_STATUS, new List <Check>()));
            checkGroup = checks[checks.Count - 1].Value;
            foreach (Host host in SelectedServers)
            {
                checkGroup.Add(new AssertCanEvacuateUpgradeCheck(host));
            }

            //PBDsPluggedCheck
            checks.Add(new KeyValuePair <string, List <Check> >(Messages.CHECKING_STORAGE_CONNECTIONS_STATUS, new List <Check>()));
            checkGroup = checks[checks.Count - 1].Value;
            foreach (Host host in SelectedServers)
            {
                checkGroup.Add(new PBDsPluggedCheck(host));
            }


            //HotfixesCheck required for MNR, Cowley, Boston and Sanibel
            bool titleAdded = false;

            foreach (var host in SelectedServers)
            {
                if (new HotfixFactory().IsHotfixRequired(host) && !ManualUpgrade)
                {
                    if (!titleAdded)
                    {
                        checks.Add(new KeyValuePair <string, List <Check> >(Messages.CHECKING_UPGRADE_HOTFIX_STATUS,
                                                                            new List <Check>()));
                        checkGroup = checks[checks.Count - 1].Value;
                        titleAdded = true;
                    }
                    checkGroup.Add(new HostHasHotfixCheck(host));
                }
            }

            //iSL (StorageLink) check
            checks.Add(new KeyValuePair <string, List <Check> >(Messages.CHECKING_STORAGELINK_STATUS, new List <Check>()));
            checkGroup = checks[checks.Count - 1].Value;
            foreach (Host host in SelectedServers)
            {
                checkGroup.Add(new HostHasUnsupportedStorageLinkSRCheck(host));
            }

            //Upgrading to Clearwater and above - license changes warning and deprecations
            if (SelectedServers.Any(h => !Helpers.ClearwaterOrGreater(h)))
            {
                //License changes
                if (SelectedServers.Any(h => Host.GetEdition(h.edition) != Host.Edition.EnterpriseXD &&
                                        Host.GetEdition(h.edition) != Host.Edition.XenDesktop))
                {
                    checks.Add(new KeyValuePair <string, List <Check> >(Messages.CHECKING_LICENSING_STATUS, new List <Check>()));
                    checkGroup = checks[checks.Count - 1].Value;
                    foreach (Host host in SelectedServers)
                    {
                        checkGroup.Add(new UpgradingFromTampaAndOlderCheck(host));
                    }
                }

                //WSS removal
                checks.Add(new KeyValuePair <string, List <Check> >(Messages.CHECKING_WSS_STATUS, new List <Check>()));
                checkGroup = checks[checks.Count - 1].Value;
                foreach (Host host in SelectedServers)
                {
                    checkGroup.Add(new HostHasWssCheck(host));
                }

                //VMP[RP]removal
                checks.Add(new KeyValuePair <string, List <Check> >(Messages.CHECKING_VMPR_STATUS, new List <Check>()));
                checkGroup = checks[checks.Count - 1].Value;
                foreach (Host host in SelectedServers)
                {
                    checkGroup.Add(new VmprActivatedCheck(host));
                }
            }

            //SafeToUpgradeCheck - in automatic mode only
            if (!ManualUpgrade)
            {
                checks.Add(new KeyValuePair <string, List <Check> >(Messages.CHECKING_SAFE_TO_UPGRADE, new List <Check>()));
                checkGroup = checks[checks.Count - 1].Value;

                foreach (Host host in SelectedServers)
                {
                    checkGroup.Add(new SafeToUpgradeCheck(host));
                }
            }

            return(checks);
        }