Exemplo n.º 1
0
        public override Problem RunCheck()
        {
            if (!Host.IsLive)
            {
                return(new HostNotLiveWarning(this, Host));
            }

            if (Helpers.CreedenceOrGreater(Host) && !Helpers.DundeeOrGreater(Host) &&
                hotfixFactory.Hotfix(HotfixFactory.HotfixableServerVersion.Creedence).ShouldBeAppliedTo(Host))
            {
                return(new HostDoesNotHaveHotfix(this, Host));
            }

            if (Helpers.SanibelOrGreater(Host) && !Helpers.CreedenceOrGreater(Host) &&
                hotfixFactory.Hotfix(HotfixFactory.HotfixableServerVersion.SanibelToClearwater).ShouldBeAppliedTo(Host))
            {
                return(new HostDoesNotHaveHotfix(this, Host));
            }

            if (!Helpers.SanibelOrGreater(Host) &&
                hotfixFactory.Hotfix(HotfixFactory.HotfixableServerVersion.Boston).ShouldBeAppliedTo(Host))
            {
                return(new HostDoesNotHaveHotfix(this, Host));
            }

            return(null);
        }
Exemplo n.º 2
0
        public override Problem RunCheck()
        {
            if (!Host.IsLive)
            {
                return(new HostNotLive(this, Host));
            }

            if (Helpers.SanibelOrGreater(Host) && !Helpers.TampaOrGreater(Host) &&
                hotfixFactory.Hotfix(HotfixFactory.HotfixableServerVersion.Sanibel).ShouldBeAppliedTo(Host))
            {
                return(new HostDoesNotHaveHotfix(this, Host));
            }

            if (Helpers.BostonOrGreater(Host) && !Helpers.SanibelOrGreater(Host) &&
                hotfixFactory.Hotfix(HotfixFactory.HotfixableServerVersion.Boston).ShouldBeAppliedTo(Host))
            {
                return(new HostDoesNotHaveHotfix(this, Host));
            }

            if (Helpers.CowleyOrGreater(Host) && !Helpers.BostonOrGreater(Host) &&
                hotfixFactory.Hotfix(HotfixFactory.HotfixableServerVersion.Cowley).ShouldBeAppliedTo(Host))
            {
                return(new HostDoesNotHaveHotfix(this, Host));
            }

            if (Helpers.MidnightRideOrGreater(Host) && !Helpers.CowleyOrGreater(Host) &&
                hotfixFactory.Hotfix(HotfixFactory.HotfixableServerVersion.MNR).ShouldBeAppliedTo(Host))
            {
                return(new HostDoesNotHaveHotfix(this, Host));
            }
            return(null);
        }
Exemplo n.º 3
0
        public void UUIDLookedUpFromEnum()
        {
            Assert.AreEqual("5b345963-ddcf-4c27-997f-3b46a79bcb07",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Dundee).UUID,
                            "Dundee UUID lookup from enum");

            Assert.AreEqual("d72c237a-eaaf-4d98-be63-48e2add8dc3a",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.ElyLima).UUID,
                            "Ely - Lima UUID lookup from enum");
        }
Exemplo n.º 4
0
        public void UUIDLookedUpFromEnum()
        {
            Assert.AreEqual("f6014211-7611-47ac-ac4c-e66bb1692c35",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Dundee).UUID,
                            "Dundee UUID lookup from enum");

            Assert.AreEqual("ddd68553-2bf8-411d-99bc-ed4a95265840",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.ElyKolkata).UUID,
                            "Ely-Jura UUID lookup from enum");
        }
Exemplo n.º 5
0
        public void UUIDLookedUpFromEnum()
        {
            Assert.AreEqual("149be566-421d-4661-bfca-e70970f86a36",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Dundee).UUID,
                            "Dundee UUID lookup from enum");

            Assert.AreEqual("d72c237a-eaaf-4d98-be63-48e2add8dc3a",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.ElyLima).UUID,
                            "Ely - Lima UUID lookup from enum");
        }
Exemplo n.º 6
0
        public void UUIDLookedUpFromEnum()
        {
            Assert.AreEqual("95ac709c-e408-423f-8d22-84b8134a149e;b412a910-0453-42ed-bae0-982cc48b00d6",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Boston).UUID,
                            "Boston UUID lookup from enum");

            Assert.AreEqual("ca0ca2c6-cc96-4e4b-946b-39ebe6652fd6",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Cowley).UUID,
                            "Cowley UUID lookup from enum");

            Assert.AreEqual("e2cb047b-66ed-4fa0-882a-67ff1726f4b9",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.MNR).UUID,
                            "MNR UUID lookup from enum");

            Assert.AreEqual("b412a910-0453-42ed-bae0-982cc48b00d6",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.SanibelToClearwater).UUID,
                            "SanibelToClearwater UUID lookup from enum");
        }
Exemplo n.º 7
0
        public void UUIDLookedUpFromEnum()
        {
            Assert.AreEqual("8d7ba04f-bcdf-4f34-afdf-acd3206b59ec;95ac709c-e408-423f-8d22-84b8134a149e",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Boston).UUID,
                            "Boston UUID lookup from enum");

            Assert.AreEqual("ca0ca2c6-cc96-4e4b-946b-39ebe6652fd6",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Cowley).UUID,
                            "Cowley UUID lookup from enum");

            Assert.AreEqual("e2cb047b-66ed-4fa0-882a-67ff1726f4b9",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.MNR).UUID,
                            "MNR UUID lookup from enum");

            Assert.AreEqual("8d7ba04f-bcdf-4f34-afdf-acd3206b59ec",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Sanibel).UUID,
                            "Sanibel UUID lookup from enum");
        }
Exemplo n.º 8
0
        public void UUIDLookedUpFromEnum()
        {
            Assert.AreEqual("95ac709c-e408-423f-8d22-84b8134a149e;591d0209-531e-4ed8-9ed2-98df2a1a445c",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Boston).UUID,
                            "Boston UUID lookup from enum");

            Assert.AreEqual("591d0209-531e-4ed8-9ed2-98df2a1a445c",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.SanibelToClearwater).UUID,
                            "SanibelToClearwater UUID lookup from enum");

            Assert.AreEqual("3f92b111-0a90-4ec6-b85a-737f241a3fc1 ",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Creedence).UUID,
                            "Creedence UUID lookup from enum");

            Assert.AreEqual("474a0f28-0d33-4c9b-9e20-52baaea8ce5e",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Dundee).UUID,
                            "Dundee UUID lookup from enum");
        }
Exemplo n.º 9
0
        protected override Problem RunHostCheck()
        {
            var hotfix = HotfixFactory.Hotfix(Host);

            if (hotfix != null && hotfix.ShouldBeAppliedTo(Host))
            {
                return(new HostDoesNotHaveHotfix(this, Host));
            }

            return(null);
        }
Exemplo n.º 10
0
        public void UUIDLookedUpFromEnum()
        {
            Assert.AreEqual("591d0209-531e-4ed8-9ed2-98df2a1a445c",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Clearwater).UUID,
                            "Clearwater UUID lookup from enum");

            Assert.AreEqual("3f92b111-0a90-4ec6-b85a-737f241a3fc1 ",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Creedence).UUID,
                            "Creedence UUID lookup from enum");

            Assert.AreEqual("474a0f28-0d33-4c9b-9e20-52baaea8ce5e",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Dundee).UUID,
                            "Dundee UUID lookup from enum");

            Assert.AreEqual("439235bf-48fa-4ee3-9c11-d67084a01205",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.ElyFalcon).UUID,
                            "Ely/Falcon UUID lookup from enum");
        }
Exemplo n.º 11
0
        public void UUIDLookedUpFromEnum()
        {
            Assert.AreEqual("591d0209-531e-4ed8-9ed2-98df2a1a445c",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Clearwater).UUID,
                            "Clearwater UUID lookup from enum");

            Assert.AreEqual("3f92b111-0a90-4ec6-b85a-737f241a3fc1 ",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Creedence).UUID,
                            "Creedence UUID lookup from enum");

            Assert.AreEqual("474a0f28-0d33-4c9b-9e20-52baaea8ce5e",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Dundee).UUID,
                            "Dundee UUID lookup from enum");

            Assert.AreEqual("b8d21409-adb7-44a5-a7ff-a78ed97162a5",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Ely).UUID,
                            "Ely UUID lookup from enum");
        }
Exemplo n.º 12
0
        public void UUIDLookedUpFromEnum()
        {
            Assert.AreEqual("591d0209-531e-4ed8-9ed2-98df2a1a445c",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Clearwater).UUID,
                            "Clearwater UUID lookup from enum");

            Assert.AreEqual("3f92b111-0a90-4ec6-b85a-737f241a3fc1 ",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Creedence).UUID,
                            "Creedence UUID lookup from enum");

            Assert.AreEqual("474a0f28-0d33-4c9b-9e20-52baaea8ce5e",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Dundee).UUID,
                            "Dundee UUID lookup from enum");

            Assert.AreEqual("c79166a9-c71d-4c3f-9cca-019a274e8d87",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.ElyJura).UUID,
                            "Ely-Jura UUID lookup from enum");
        }
Exemplo n.º 13
0
        public void UUIDLookedUpFromEnum()
        {
            Assert.AreEqual("591d0209-531e-4ed8-9ed2-98df2a1a445c",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Clearwater).UUID,
                            "Clearwater UUID lookup from enum");

            Assert.AreEqual("3f92b111-0a90-4ec6-b85a-737f241a3fc1 ",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Creedence).UUID,
                            "Creedence UUID lookup from enum");

            Assert.AreEqual("f6014211-7611-47ac-ac4c-e66bb1692c35",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Dundee).UUID,
                            "Dundee UUID lookup from enum");

            Assert.AreEqual("ddd68553-2bf8-411d-99bc-ed4a95265840",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.ElyJura).UUID,
                            "Ely-Jura UUID lookup from enum");
        }
Exemplo n.º 14
0
        public void UUIDLookedUpFromEnum()
        {
            Assert.AreEqual("591d0209-531e-4ed8-9ed2-98df2a1a445c",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Clearwater).UUID,
                            "Clearwater UUID lookup from enum");

            Assert.AreEqual("3f92b111-0a90-4ec6-b85a-737f241a3fc1 ",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Creedence).UUID,
                            "Creedence UUID lookup from enum");

            Assert.AreEqual("474a0f28-0d33-4c9b-9e20-52baaea8ce5e",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Dundee).UUID,
                            "Dundee UUID lookup from enum");

            Assert.AreEqual("1ac61687-8b65-43e6-957f-50602fb79572",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Ely).UUID,
                            "Ely UUID lookup from enum");
        }
Exemplo n.º 15
0
 protected override Actions.AsyncAction CreateAction(out bool cancelled)
 {
     cancelled = false;
     return(new Actions.DelegatedAsyncAction(Server.Connection, string.Format(Messages.APPLYING_HOTFIX_TO_HOST, Server), "", "",
                                             (ss) =>
     {
         Hotfix hotfix = hotfixFactory.Hotfix(Server);
         if (hotfix != null)
         {
             hotfix.Apply(Server, ss);
         }
     }, true));
 }
Exemplo n.º 16
0
        protected override Problem RunHostCheck()
        {
            if (!_pool.ssl_legacy() || Helpers.StockholmOrGreater(Host))
            {
                return(null);
            }

            //update case
            if (_newVersion != null)
            {
                if (_newVersion.Version.CompareTo(new Version(BrandManager.ProductVersion82)) >= 0)
                {
                    return(new LegacySslProblem(this, _pool));
                }
                return(null);
            }

            //upgrade case

            if (!_manualUpgrade)
            {
                var hotfix = HotfixFactory.Hotfix(Host);
                if (hotfix != null && hotfix.ShouldBeAppliedTo(Host))
                {
                    return(new HostDoesNotHaveHotfixWarning(this, Host));
                }
            }

            string upgradePlatformVersion = null;

            if (_installMethodConfig != null)
            {
                Host.TryGetUpgradeVersion(Host, _installMethodConfig, out upgradePlatformVersion, out _);
            }

            // we don't know the upgrade version, so add generic warning
            // (this is the case of the manual upgrade or when the rpu plugin doesn't have the function)
            if (string.IsNullOrEmpty(upgradePlatformVersion))
            {
                return(new LegacySslWarning(this, _pool));
            }

            // we know they are upgrading to Stockholm or greater, so block them
            if (Helpers.StockholmOrGreater(upgradePlatformVersion))
            {
                return(new LegacySslProblem(this, _pool));
            }

            return(null);
        }
Exemplo n.º 17
0
        protected override Problem RunCheck()
        {
            if (!Host.IsLive())
            {
                return(new HostNotLiveWarning(this, Host));
            }

            var hotfix = hotfixFactory.Hotfix(Host);

            if (hotfix != null && hotfix.ShouldBeAppliedTo(Host))
            {
                return(new HostDoesNotHaveHotfix(this, Host));
            }

            return(null);
        }
Exemplo n.º 18
0
        public void UUIDLookedUpFromEnum()
        {
            Assert.AreEqual("149be566-421d-4661-bfca-e70970f86a36",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Dundee).UUID,
                            "Dundee UUID lookup from enum");

            Assert.AreEqual("072bf802-c54d-4e0d-b110-f0647ea86e32",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.ElyKolkata).UUID,
                            "Ely - Kolkata UUID lookup from enum");

            Assert.AreEqual("660e3036-a090-44b5-a06b-10b3bd929855",
                            factory.Hotfix(HotfixFactory.HotfixableServerVersion.Lima).UUID,
                            "Lima UUID lookup from enum");
        }
Exemplo n.º 19
0
        protected override Problem RunHostCheck()
        {
            //update case
            if (!_upgrade)
            {
                return(new PoolHasPVGuestWarningUrl(this, _pool));
            }

            //upgrade case

            if (!_manualUpgrade)
            {
                var hotfix = HotfixFactory.Hotfix(Host);
                if (hotfix != null && hotfix.ShouldBeAppliedTo(Host))
                {
                    return(new HostDoesNotHaveHotfixWarning(this, Host));
                }
            }

            string upgradePlatformVersion = null;

            if (_installMethodConfig != null)
            {
                Host.TryGetUpgradeVersion(Host, _installMethodConfig, out upgradePlatformVersion, out _);
            }

            // we don't know the upgrade version, so add warning
            // (this is the case of the manual upgrade or when the rpu plugin doesn't have the function)
            if (string.IsNullOrEmpty(upgradePlatformVersion))
            {
                return(new PoolHasPVGuestWarningUrl(this, _pool));
            }

            if (Helpers.QuebecOrGreater(upgradePlatformVersion))
            {
                return(new PoolHasPVGuestWarningUrl(this, _pool));
            }

            return(null);
        }
Exemplo n.º 20
0
        protected override Problem RunHostCheck()
        {
            var hotfix = HotfixFactory.Hotfix(Host);

            if (hotfix != null && hotfix.ShouldBeAppliedTo(Host))
            {
                return(new HostDoesNotHaveHotfixWarning(this, Host));
            }

            try
            {
                var result = Host.call_plugin(Host.Connection.Session, Host.opaque_ref, "prepare_host_upgrade.py", "testSafe2Upgrade", _installMethodConfig);

                if (result.ToLowerInvariant() == "true")
                {
                    return(null);
                }

                Host.TryGetUpgradeVersion(Host, _installMethodConfig, out var upgradePlatformVersion, out _);

                // block the upgrade to a post-Stockholm version
                if (Helpers.PostStockholm(upgradePlatformVersion))
                {
                    switch (result.ToLowerInvariant())
                    {
                    case "not_enough_space":
                        return(new HostNotSafeToUpgradeProblem(this, Host, HostNotSafeToUpgradeReason.NotEnoughSpace));

                    case "vdi_present":
                        return(new HostNotSafeToUpgradeProblem(this, Host, HostNotSafeToUpgradeReason.VdiPresent));

                    case "utility_part_present":
                        return(new HostNotSafeToUpgradeProblem(this, Host, HostNotSafeToUpgradeReason.UtilityPartitionPresent));

                    case "legacy_partition_table":
                        return(new HostNotSafeToUpgradeProblem(this, Host, HostNotSafeToUpgradeReason.LegacyPartitionTable));

                    default:
                        return(new HostNotSafeToUpgradeProblem(this, Host, HostNotSafeToUpgradeReason.Default));
                    }
                }

                // add a warning for older or unknown upgrade version
                switch (result.ToLowerInvariant())
                {
                case "not_enough_space":
                    return(new HostNotSafeToUpgradeWarning(this, Host, HostNotSafeToUpgradeReason.NotEnoughSpace));

                case "vdi_present":
                    return(new HostNotSafeToUpgradeWarning(this, Host, HostNotSafeToUpgradeReason.VdiPresent));

                case "utility_part_present":
                    return(new HostNotSafeToUpgradeWarning(this, Host, HostNotSafeToUpgradeReason.UtilityPartitionPresent));

                case "legacy_partition_table":
                    return(new HostNotSafeToUpgradeWarning(this, Host, HostNotSafeToUpgradeReason.LegacyPartitionTable));

                default:
                    return(new HostNotSafeToUpgradeWarning(this, Host, HostNotSafeToUpgradeReason.Default));
                }
            }
            catch (Exception exception)
            {
                //note: handle the case when we get UNKNOWN_XENAPI_PLUGIN_FUNCTION - testSafe2Upgrade
                log.Warn($"Plugin call prepare_host_upgrade.testSafe2Upgrade on {Host.Name()} threw an exception.", exception);
            }

            return(null);
        }