Kiu/xenadmin
1
0
Fork 0
mirror of https://github.com/xcp-ng/xenadmin.git synced 2025-01-20 23:39:51 +01:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge pull request #2807 from xenserver/feature/legacy-partition

Browse Source 
Merge feature/legacy-partition to master
This commit is contained in:
Konstantina Chremmou 2021-05-04 13:06:16 +01:00 committed by GitHub
commit e3e73c8a0a
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
12 changed files with 472 additions and 244 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
Branding/Branding.resx
View File

@ -180,4 +180,7 @@
<data name="PRODUCT_VERSION_8_2" xml:space="preserve">
<value>8.2</value>
</data>
<data name="PRODUCT_VERSION_POST_8_2" xml:space="preserve">
<value>Citrix Hypervisor 8.2.50</value>
</data>
</root>

2
WixInstaller/XenCenter.wxs
View File

@ -142,7 +142,7 @@
<Component Id="UpdateFiles" Guid="$(var.UpdateFilesGuid)">
<File Id="hotfixDundee" Source="$(env.RepoRoot)\Branding\Hotfixes\RPU003.$(var.FileExtUpdate)" />
<File Id="hotfixEly" Source="$(env.RepoRoot)\Branding\Hotfixes\RPU004.iso" />
<File Id="hotfixNaples" Source="$(env.RepoRoot)\Branding\Hotfixes\RPU005.iso" />
<File Id="hotfixStockholm" Source="$(env.RepoRoot)\Branding\Hotfixes\RPU005.iso" />
</Component>
<Directory Id="ja" Name="ja">
<Component Id="JaResources" Guid="$(var.JapaneseResxGuid)">

2
XenAdmin/Diagnostics/Checks/PoolHasGFS2SR.cs
View File

@ -44,6 +44,8 @@ namespace XenAdmin.Diagnostics.Checks
{
}
public override bool CanRun() => Helpers.KolkataOrGreater(Host.Connection) && !Helpers.LimaOrGreater(Host.Connection);
protected override Problem RunHostCheck()
{
var clusteringEnabled = Host.Connection.Cache.Cluster_hosts.Any(cluster => cluster.enabled);

190
XenAdmin/Diagnostics/Checks/SafeToUpgradeCheck.cs
View File

@ -1,83 +1,115 @@
/* 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.
*/
/* 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 XenAdmin.Diagnostics.Problems;
using XenAdmin.Diagnostics.Problems.HostProblem;
using XenAPI;
namespace XenAdmin.Diagnostics.Checks
using System.Collections.Generic;
using XenAdmin.Core;
using XenAdmin.Diagnostics.Hotfixing;
using XenAdmin.Diagnostics.Problems;
using XenAdmin.Diagnostics.Problems.HostProblem;
using XenAPI;
namespace XenAdmin.Diagnostics.Checks
{
class SafeToUpgradeCheck : HostPostLivenessCheck
{
private static readonly log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
public SafeToUpgradeCheck(Host host)
: base(host)
{
class SafeToUpgradeCheck : HostPostLivenessCheck
{
private static readonly log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
private readonly Dictionary<string, string> _installMethodConfig;
public SafeToUpgradeCheck(Host host, Dictionary<string, string> installMethodConfig)
: base(host)
{
_installMethodConfig = installMethodConfig;
}
public override bool CanRun() => !Helpers.PostStockholm(Host);
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;
}
protected override Problem RunHostCheck()
{
try
{
var config = new Dictionary<string, string>();
var result = Host.call_plugin(Host.Connection.Session, Host.opaque_ref, "prepare_host_upgrade.py", "testSafe2Upgrade", config);
switch (result.ToLowerInvariant())
{
case "true":
return null;
case "not_enough_space":
return new HostNotSafeToUpgradeWarning(this, Host, HostNotSafeToUpgradeReason.NotEnoughSpace);
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;
}
public override string Description
{
get { return Messages.CHECKING_SAFE_TO_UPGRADE_DESCRIPTION; }
}
}
}
public override string Description => Messages.CHECKING_SAFE_TO_UPGRADE_DESCRIPTION;
}
}

14
XenAdmin/Diagnostics/Hotfixing/HotfixFactory.cs
View File

@ -41,7 +41,7 @@ namespace XenAdmin.Diagnostics.Hotfixing
{
Dundee,
ElyLima,
Naples
Stockholm
}
private static readonly Hotfix dundeeHotfix = new SingleHotfix
@ -56,16 +56,16 @@ namespace XenAdmin.Diagnostics.Hotfixing
UUID = "1821854d-0171-4696-a9c4-01daf75a45a0"
};
private static readonly Hotfix naplesHotfix = new SingleHotfix
private static readonly Hotfix stockholmHotfix = new SingleHotfix
{
Filename = "RPU005",
UUID = "b43ea62d-2804-4589-9164-f6cc5867d011"
UUID = "bca031a8-db23-4932-833d-20170b2ae565"
};
public static Hotfix Hotfix(Host host)
{
if (Helpers.NaplesOrGreater(host) && !Helpers.QuebecOrGreater(host))
return Hotfix(HotfixableServerVersion.Naples);
if (Helpers.StockholmOrGreater(host) && !Helpers.PostStockholm(host))
return Hotfix(HotfixableServerVersion.Stockholm);
if (Helpers.ElyOrGreater(host) && !Helpers.NaplesOrGreater(host))
return Hotfix(HotfixableServerVersion.ElyLima);
if (Helpers.DundeeOrGreater(host) && !Helpers.ElyOrGreater(host))
@ -75,8 +75,8 @@ namespace XenAdmin.Diagnostics.Hotfixing
public static Hotfix Hotfix(HotfixableServerVersion version)
{
if (version == HotfixableServerVersion.Naples)
return naplesHotfix;
if (version == HotfixableServerVersion.Stockholm)
return stockholmHotfix;
if (version == HotfixableServerVersion.ElyLima)
return elyLimaHotfix;
if (version == HotfixableServerVersion.Dundee)

215
XenAdmin/Diagnostics/Problems/HostProblem/HostNotSafeToUpgradeWarning.cs
View File

@ -1,87 +1,130 @@
/* 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 XenAdmin.Core;
using XenAdmin.Diagnostics.Checks;
using XenAPI;
namespace XenAdmin.Diagnostics.Problems.HostProblem
{
public enum HostNotSafeToUpgradeReason { NotEnoughSpace, Default }
public class HostNotSafeToUpgradeWarning : WarningWithMoreInfo
{
private readonly Host host;
private HostNotSafeToUpgradeReason reason;
public HostNotSafeToUpgradeWarning(Check check, Host host, HostNotSafeToUpgradeReason reason)
: base(check)
{
this.host = host;
this.reason = reason;
}
public override string Title => Description;
public override string Description => String.Format(ShortMessage, host.name_label);
public override string Message
{
get
{
switch (reason)
{
case HostNotSafeToUpgradeReason.NotEnoughSpace :
return string.Format(Messages.NOT_SAFE_TO_UPGRADE_NOT_ENOUGH_SPACE_LONG, BrandManager.ProductVersion70);
default:
return string.Format(Messages.NOT_SAFE_TO_UPGRADE_DEFAULT_WARNING_LONG, BrandManager.ProductVersion70);
}
}
}
private string ShortMessage
{
get
{
switch (reason)
{
case HostNotSafeToUpgradeReason.NotEnoughSpace:
return Messages.NOT_SAFE_TO_UPGRADE_NOT_ENOUGH_SPACE_SHORT;
default:
return Messages.NOT_SAFE_TO_UPGRADE_DEFAULT_WARNING_SHORT;
}
}
/* 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 XenAdmin.Core;
using XenAdmin.Diagnostics.Checks;
using XenAPI;
namespace XenAdmin.Diagnostics.Problems.HostProblem
{
public enum HostNotSafeToUpgradeReason { NotEnoughSpace, VdiPresent, UtilityPartitionPresent, LegacyPartitionTable, Default }
public class HostNotSafeToUpgradeWarning : WarningWithMoreInfo
{
private readonly Host _host;
private readonly string _shortMessage;
public HostNotSafeToUpgradeWarning(Check check, Host host, HostNotSafeToUpgradeReason reason)
: base(check)
{
_host = host;
var newPartitionInfo = string.Format(Messages.NOT_SAFE_TO_UPGRADE_NEW_PARTITION_INFO, BrandManager.ProductVersionPost82);
string detail;
switch (reason)
{
case HostNotSafeToUpgradeReason.NotEnoughSpace:
_shortMessage = Messages.NOT_SAFE_TO_UPGRADE_NOT_ENOUGH_SPACE;
detail = string.Format(Messages.NOT_SAFE_TO_UPGRADE_NOT_ENOUGH_SPACE_WARNING, BrandManager.ProductVersionPost82);
break;
case HostNotSafeToUpgradeReason.VdiPresent:
_shortMessage = Messages.NOT_SAFE_TO_UPGRADE_VDI_PRESENT;
detail = string.Format(Messages.NOT_SAFE_TO_UPGRADE_VDI_PRESENT_WARNING, BrandManager.ProductVersionPost82);
break;
case HostNotSafeToUpgradeReason.UtilityPartitionPresent:
_shortMessage = Messages.NOT_SAFE_TO_UPGRADE_UTILITY_PARTITION;
detail = string.Format(Messages.NOT_SAFE_TO_UPGRADE_UTILITY_PARTITION_WARNING, BrandManager.ProductVersionPost82);
break;
case HostNotSafeToUpgradeReason.LegacyPartitionTable:
_shortMessage = Messages.NOT_SAFE_TO_UPGRADE_LEGACY_PARTITION_TABLE;
detail = string.Format(Messages.NOT_SAFE_TO_UPGRADE_LEGACY_PARTITION_TABLE_WARNING, BrandManager.ProductVersionPost82);
break;
default:
_shortMessage = Messages.NOT_SAFE_TO_UPGRADE_DEFAULT;
detail = string.Format(Messages.NOT_SAFE_TO_UPGRADE_DEFAULT_WARNING, BrandManager.ProductVersionPost82);
break;
}
Message = $"{_shortMessage}\n\n{newPartitionInfo}\n\n{detail}";
}
}
}
public override string Message { get; }
public override string Title => Description;
public override string Description => string.Format(Messages.UPDATES_WIZARD_PRECHECK_FAILED, _host.name_label, _shortMessage);
}
public class HostNotSafeToUpgradeProblem : ProblemWithMoreInfo
{
private readonly Host _host;
private readonly string _shortMessage;
public HostNotSafeToUpgradeProblem(Check check, Host host, HostNotSafeToUpgradeReason reason)
: base(check)
{
_host = host;
var newPartitionInfo = string.Format(Messages.NOT_SAFE_TO_UPGRADE_NEW_PARTITION_INFO, BrandManager.ProductVersionPost82);
string detail;
switch (reason)
{
case HostNotSafeToUpgradeReason.NotEnoughSpace:
_shortMessage = Messages.NOT_SAFE_TO_UPGRADE_NOT_ENOUGH_SPACE;
detail = string.Format(Messages.NOT_SAFE_TO_UPGRADE_NOT_ENOUGH_SPACE_PROBLEM, BrandManager.ProductVersionPost82);
break;
case HostNotSafeToUpgradeReason.VdiPresent:
_shortMessage = Messages.NOT_SAFE_TO_UPGRADE_VDI_PRESENT;
detail = string.Format(Messages.NOT_SAFE_TO_UPGRADE_VDI_PRESENT_PROBLEM, BrandManager.ProductVersionPost82);
break;
case HostNotSafeToUpgradeReason.UtilityPartitionPresent:
_shortMessage = Messages.NOT_SAFE_TO_UPGRADE_UTILITY_PARTITION;
detail = string.Format(Messages.NOT_SAFE_TO_UPGRADE_UTILITY_PARTITION_PROBLEM, BrandManager.ProductVersionPost82);
break;
case HostNotSafeToUpgradeReason.LegacyPartitionTable:
_shortMessage = Messages.NOT_SAFE_TO_UPGRADE_LEGACY_PARTITION_TABLE;
detail = string.Format(Messages.NOT_SAFE_TO_UPGRADE_LEGACY_PARTITION_TABLE_PROBLEM, BrandManager.ProductVersionPost82);
break;
default:
_shortMessage = Messages.NOT_SAFE_TO_UPGRADE_DEFAULT;
detail = string.Format(Messages.NOT_SAFE_TO_UPGRADE_DEFAULT_PROBLEM, BrandManager.ProductVersionPost82);
break;
}
Message = $"{_shortMessage}\n\n{newPartitionInfo}\n\n{detail}";
}
public override string Message { get; }
public override string Title => Description;
public override string Description => string.Format(Messages.UPDATES_WIZARD_PRECHECK_FAILED, _host.name_label, _shortMessage);
}
}

68
XenAdmin/Wizards/RollingUpgradeWizard/RollingUpgradeWizardPrecheckPage.cs
View File

@ -188,15 +188,19 @@ namespace XenAdmin.Wizards.RollingUpgradeWizard
//SafeToUpgrade- and PrepareToUpgrade- checks - in automatic mode only, for hosts that will be upgraded
if (!ManualUpgrade)
{
var prepareToUpgradeChecks = new List<Check>();
foreach (var host in hostsToUpgrade)
prepareToUpgradeChecks.Add(new PrepareToUpgradeCheck(host, InstallMethodConfig));
groups.Add(new CheckGroup(Messages.CHECKING_PREPARE_TO_UPGRADE, prepareToUpgradeChecks));
var safeToUpgradeChecks = (from Host host in hostsToUpgrade
let check = new SafeToUpgradeCheck(host, InstallMethodConfig)
where check.CanRun()
select check as Check).ToList();
var safeToUpgradeChecks = new List<Check>();
foreach (var host in hostsToUpgrade)
safeToUpgradeChecks.Add(new SafeToUpgradeCheck(host));
groups.Add(new CheckGroup(Messages.CHECKING_SAFE_TO_UPGRADE, safeToUpgradeChecks));
if (safeToUpgradeChecks.Count > 0)
groups.Add(new CheckGroup(Messages.CHECKING_SAFE_TO_UPGRADE, safeToUpgradeChecks));
var prepareToUpgradeChecks = (from Host host in hostsToUpgrade
select new PrepareToUpgradeCheck(host, InstallMethodConfig) as Check).ToList();
if (prepareToUpgradeChecks.Count > 0)
groups.Add(new CheckGroup(Messages.CHECKING_PREPARE_TO_UPGRADE, prepareToUpgradeChecks));
}
//vSwitch controller check - for each pool
@ -238,41 +242,39 @@ namespace XenAdmin.Wizards.RollingUpgradeWizard
//HA checks - for each pool
var haChecks = (from Host server in SelectedMasters
select new HAOffCheck(server) as Check).ToList();
groups.Add(new CheckGroup(Messages.CHECKING_HA_STATUS, haChecks));
if (haChecks.Count > 0)
groups.Add(new CheckGroup(Messages.CHECKING_HA_STATUS, haChecks));
//Checking can evacuate host - for hosts that will be upgraded or updated
var evacuateChecks = new List<Check>();
foreach (Host host in hostsToUpgradeOrUpdate)
evacuateChecks.Add(new AssertCanEvacuateUpgradeCheck(host));
groups.Add(new CheckGroup(Messages.CHECKING_CANEVACUATE_STATUS, evacuateChecks));
var evacuateChecks = (from Host host in hostsToUpgradeOrUpdate
select new AssertCanEvacuateUpgradeCheck(host) as Check).ToList();
if (evacuateChecks.Count > 0)
groups.Add(new CheckGroup(Messages.CHECKING_CANEVACUATE_STATUS, evacuateChecks));
//PBDsPluggedCheck - for hosts that will be upgraded or updated
var pbdChecks = new List<Check>();
foreach (Host host in hostsToUpgradeOrUpdate)
pbdChecks.Add(new PBDsPluggedCheck(host));
groups.Add(new CheckGroup(Messages.CHECKING_STORAGE_CONNECTIONS_STATUS, pbdChecks));
var pbdChecks = (from Host host in hostsToUpgradeOrUpdate
select new PBDsPluggedCheck(host) as Check).ToList();
if(pbdChecks.Count > 0)
groups.Add(new CheckGroup(Messages.CHECKING_STORAGE_CONNECTIONS_STATUS, pbdChecks));
//HostMemoryPostUpgradeCheck - for hosts that will be upgraded
var mostMemoryPostUpgradeChecks = new List<Check>();
foreach (var host in hostsToUpgrade)
{
mostMemoryPostUpgradeChecks.Add(new HostMemoryPostUpgradeCheck(host, InstallMethodConfig));
}
var mostMemoryPostUpgradeChecks = (from Host host in hostsToUpgrade
select new HostMemoryPostUpgradeCheck(host, InstallMethodConfig) as Check).ToList();
if (mostMemoryPostUpgradeChecks.Count > 0)
groups.Add(new CheckGroup(Messages.CHECKING_HOST_MEMORY_POST_UPGRADE, mostMemoryPostUpgradeChecks));
var gfs2Checks = new List<Check>();
foreach (Pool pool in SelectedPools.Where(p =>
Helpers.KolkataOrGreater(p.Connection) && !Helpers.LimaOrGreater(p.Connection)))
{
Host host = pool.Connection.Resolve(pool.master);
gfs2Checks.Add(new PoolHasGFS2SR(host));
}
if (gfs2Checks.Count > 0)
{
//PoolHasGFS2SR checks
var gfs2Checks = (from Host host in SelectedMasters
let check = new PoolHasGFS2SR(host)
where check.CanRun()
select check as Check).ToList();
if (gfs2Checks.Count > 0)
groups.Add(new CheckGroup(Messages.CHECKING_CLUSTERING_STATUS, gfs2Checks));
}
//Checking automated updates are possible if apply updates checkbox is ticked
if (ApplyUpdatesToNewVersion)

2
XenModel/BrandManager.cs
View File

@ -65,6 +65,8 @@ namespace XenAdmin.Core
public static string ProductVersion82 => Get("PRODUCT_VERSION_8_2");
public static string ProductVersionPost82 => Get("PRODUCT_VERSION_POST_8_2");
public const string PRODUCT_BRAND = "[XenServer product]";
public const string COMPANY_NAME_SHORT = "[Citrix]";

140
XenModel/Messages.Designer.cs generated
View File

@ -28093,46 +28093,146 @@ namespace XenAdmin {
}
/// <summary>
/// Looks up a localized string similar to VMs on local disk will prevent disk repartitioning.
///
///A new disk partitioning scheme is available in [XenServer] {0} and above that includes larger dom0 and backup partitions, and dedicated partitions for logging, swap and UEFI.
///
///However, there are VMs on local storage, so the current partitioning scheme will be retained. To benefit from repartitioning on upgrade to [XenServer] {0} or above, VMs must be moved from local storage first..
/// Looks up a localized string similar to Disk repartitioning is not possible..
/// </summary>
public static string NOT_SAFE_TO_UPGRADE_DEFAULT_WARNING_LONG {
public static string NOT_SAFE_TO_UPGRADE_DEFAULT {
get {
return ResourceManager.GetString("NOT_SAFE_TO_UPGRADE_DEFAULT_WARNING_LONG", resourceCulture);
return ResourceManager.GetString("NOT_SAFE_TO_UPGRADE_DEFAULT", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to {0}: VMs on local disk will prevent disk repartitioning..
/// Looks up a localized string similar to However, the new partitioning scheme cannot be applied on your server. This could be because there are VMs on local storage, the partition table type is DOS or there is a utility partition present. To upgrade to {0}, you must identify and resolve the issue first..
/// </summary>
public static string NOT_SAFE_TO_UPGRADE_DEFAULT_WARNING_SHORT {
public static string NOT_SAFE_TO_UPGRADE_DEFAULT_PROBLEM {
get {
return ResourceManager.GetString("NOT_SAFE_TO_UPGRADE_DEFAULT_WARNING_SHORT", resourceCulture);
return ResourceManager.GetString("NOT_SAFE_TO_UPGRADE_DEFAULT_PROBLEM", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The disk size of the local storage prevents repartitioning.
///
///A new disk partitioning scheme is available in [XenServer] {0} and above that includes larger dom0 and backup partitions, and dedicated partitions for logging, swap and UEFI.
///
///However, there is not enough space to perform the repartitioning, so the current partitioning scheme will be retained..
/// Looks up a localized string similar to However, the new partitioning scheme cannot be applied on your server. This could be because there are VMs on local storage, the partition table type is DOS or there is a utility partition present. To upgrade to {0} or above, or to benefit from repartitioning on upgrade to a version older than {0}, you must identify and resolve the issue first..
/// </summary>
public static string NOT_SAFE_TO_UPGRADE_NOT_ENOUGH_SPACE_LONG {
public static string NOT_SAFE_TO_UPGRADE_DEFAULT_WARNING {
get {
return ResourceManager.GetString("NOT_SAFE_TO_UPGRADE_NOT_ENOUGH_SPACE_LONG", resourceCulture);
return ResourceManager.GetString("NOT_SAFE_TO_UPGRADE_DEFAULT_WARNING", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to {0}: The disk size of the local storage prevents repartitioning..
/// Looks up a localized string similar to The partition table type prevents repartitioning..
/// </summary>
public static string NOT_SAFE_TO_UPGRADE_NOT_ENOUGH_SPACE_SHORT {
public static string NOT_SAFE_TO_UPGRADE_LEGACY_PARTITION_TABLE {
get {
return ResourceManager.GetString("NOT_SAFE_TO_UPGRADE_NOT_ENOUGH_SPACE_SHORT", resourceCulture);
return ResourceManager.GetString("NOT_SAFE_TO_UPGRADE_LEGACY_PARTITION_TABLE", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to However, the partition table type on your server is DOS, which prevents repartitioning. The current partitioning scheme cannot be retained. Therefore the server cannot be upgraded to {0}..
/// </summary>
public static string NOT_SAFE_TO_UPGRADE_LEGACY_PARTITION_TABLE_PROBLEM {
get {
return ResourceManager.GetString("NOT_SAFE_TO_UPGRADE_LEGACY_PARTITION_TABLE_PROBLEM", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to However, the partition table type on your server is DOS, which prevents repartitioning. The current partitioning scheme cannot be retained if you upgrade to {0} or above, so an upgrade to {0} or above is not possible. .
/// </summary>
public static string NOT_SAFE_TO_UPGRADE_LEGACY_PARTITION_TABLE_WARNING {
get {
return ResourceManager.GetString("NOT_SAFE_TO_UPGRADE_LEGACY_PARTITION_TABLE_WARNING", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to As of {0} the current partitioning scheme is no longer supported. A new disk partitioning scheme is available that includes larger dom0 and backup partitions, and dedicated partitions for logging, swap and UEFI..
/// </summary>
public static string NOT_SAFE_TO_UPGRADE_NEW_PARTITION_INFO {
get {
return ResourceManager.GetString("NOT_SAFE_TO_UPGRADE_NEW_PARTITION_INFO", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to The disk size of the local storage prevents repartitioning..
/// </summary>
public static string NOT_SAFE_TO_UPGRADE_NOT_ENOUGH_SPACE {
get {
return ResourceManager.GetString("NOT_SAFE_TO_UPGRADE_NOT_ENOUGH_SPACE", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to However, there is not enough space to perform the repartitioning. To upgrade to {0}, the size of the local storage needs to be increased first..
/// </summary>
public static string NOT_SAFE_TO_UPGRADE_NOT_ENOUGH_SPACE_PROBLEM {
get {
return ResourceManager.GetString("NOT_SAFE_TO_UPGRADE_NOT_ENOUGH_SPACE_PROBLEM", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to However, there is not enough space to perform the repartitioning. The current partitioning scheme cannot be retained if you upgrade to {0} or above, so the size of the local storage needs to be increased first..
/// </summary>
public static string NOT_SAFE_TO_UPGRADE_NOT_ENOUGH_SPACE_WARNING {
get {
return ResourceManager.GetString("NOT_SAFE_TO_UPGRADE_NOT_ENOUGH_SPACE_WARNING", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to A utility partition prevents repartitioning..
/// </summary>
public static string NOT_SAFE_TO_UPGRADE_UTILITY_PARTITION {
get {
return ResourceManager.GetString("NOT_SAFE_TO_UPGRADE_UTILITY_PARTITION", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to However, there is a utility partition present which prevents repartitioning. To upgrade to {0}, the utility partition must be removed..
/// </summary>
public static string NOT_SAFE_TO_UPGRADE_UTILITY_PARTITION_PROBLEM {
get {
return ResourceManager.GetString("NOT_SAFE_TO_UPGRADE_UTILITY_PARTITION_PROBLEM", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to However, there is a utility partition present which prevents repartitioning. The current partitioning scheme cannot be retained if you upgrade to {0} or above, so the existing utility partition must be removed first..
/// </summary>
public static string NOT_SAFE_TO_UPGRADE_UTILITY_PARTITION_WARNING {
get {
return ResourceManager.GetString("NOT_SAFE_TO_UPGRADE_UTILITY_PARTITION_WARNING", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to VMs on local disk will prevent disk repartitioning..
/// </summary>
public static string NOT_SAFE_TO_UPGRADE_VDI_PRESENT {
get {
return ResourceManager.GetString("NOT_SAFE_TO_UPGRADE_VDI_PRESENT", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to However, there are VMs on local storage, so the new disk partitioning can not be applied. To upgrade to {0} or above, VMs must be moved from local storage first..
/// </summary>
public static string NOT_SAFE_TO_UPGRADE_VDI_PRESENT_PROBLEM {
get {
return ResourceManager.GetString("NOT_SAFE_TO_UPGRADE_VDI_PRESENT_PROBLEM", resourceCulture);
}
}
/// <summary>
/// Looks up a localized string similar to However, there are VMs on local storage, so the new partitioning scheme cannot be applied. To upgrade to {0} or above, or to benefit from repartitioning on upgrade to a version older than {0}, VMs must be moved from local storage first..
/// </summary>
public static string NOT_SAFE_TO_UPGRADE_VDI_PRESENT_WARNING {
get {
return ResourceManager.GetString("NOT_SAFE_TO_UPGRADE_VDI_PRESENT_WARNING", resourceCulture);
}
}

62
XenModel/Messages.resx
View File

@ -9758,25 +9758,53 @@ It is strongly recommended that you Cancel and apply the latest version of the p
<data name="NOT_IN_A_FOLDER" xml:space="preserve">
<value>Not in any folder</value>
</data>
<data name="NOT_SAFE_TO_UPGRADE_DEFAULT_WARNING_LONG" xml:space="preserve">
<value>VMs on local disk will prevent disk repartitioning.
A new disk partitioning scheme is available in [XenServer] {0} and above that includes larger dom0 and backup partitions, and dedicated partitions for logging, swap and UEFI.
However, there are VMs on local storage, so the current partitioning scheme will be retained. To benefit from repartitioning on upgrade to [XenServer] {0} or above, VMs must be moved from local storage first.</value>
<data name="NOT_SAFE_TO_UPGRADE_DEFAULT" xml:space="preserve">
<value>Disk repartitioning is not possible.</value>
</data>
<data name="NOT_SAFE_TO_UPGRADE_DEFAULT_WARNING_SHORT" xml:space="preserve">
<value>{0}: VMs on local disk will prevent disk repartitioning.</value>
<data name="NOT_SAFE_TO_UPGRADE_DEFAULT_PROBLEM" xml:space="preserve">
<value>However, the new partitioning scheme cannot be applied on your server. This could be because there are VMs on local storage, the partition table type is DOS or there is a utility partition present. To upgrade to {0}, you must identify and resolve the issue first.</value>
</data>
<data name="NOT_SAFE_TO_UPGRADE_NOT_ENOUGH_SPACE_LONG" xml:space="preserve">
<value>The disk size of the local storage prevents repartitioning.
A new disk partitioning scheme is available in [XenServer] {0} and above that includes larger dom0 and backup partitions, and dedicated partitions for logging, swap and UEFI.
However, there is not enough space to perform the repartitioning, so the current partitioning scheme will be retained.</value>
<data name="NOT_SAFE_TO_UPGRADE_DEFAULT_WARNING" xml:space="preserve">
<value>However, the new partitioning scheme cannot be applied on your server. This could be because there are VMs on local storage, the partition table type is DOS or there is a utility partition present. To upgrade to {0} or above, or to benefit from repartitioning on upgrade to a version older than {0}, you must identify and resolve the issue first.</value>
</data>
<data name="NOT_SAFE_TO_UPGRADE_NOT_ENOUGH_SPACE_SHORT" xml:space="preserve">
<value>{0}: The disk size of the local storage prevents repartitioning.</value>
<data name="NOT_SAFE_TO_UPGRADE_LEGACY_PARTITION_TABLE" xml:space="preserve">
<value>The partition table type prevents repartitioning.</value>
</data>
<data name="NOT_SAFE_TO_UPGRADE_LEGACY_PARTITION_TABLE_PROBLEM" xml:space="preserve">
<value>However, the partition table type on your server is DOS, which prevents repartitioning. The current partitioning scheme cannot be retained. Therefore the server cannot be upgraded to {0}.</value>
</data>
<data name="NOT_SAFE_TO_UPGRADE_LEGACY_PARTITION_TABLE_WARNING" xml:space="preserve">
<value>However, the partition table type on your server is DOS, which prevents repartitioning. The current partitioning scheme cannot be retained if you upgrade to {0} or above, so an upgrade to {0} or above is not possible. </value>
</data>
<data name="NOT_SAFE_TO_UPGRADE_NEW_PARTITION_INFO" xml:space="preserve">
<value>As of {0} the current partitioning scheme is no longer supported. A new disk partitioning scheme is available that includes larger dom0 and backup partitions, and dedicated partitions for logging, swap and UEFI.</value>
</data>
<data name="NOT_SAFE_TO_UPGRADE_NOT_ENOUGH_SPACE" xml:space="preserve">
<value>The disk size of the local storage prevents repartitioning.</value>
</data>
<data name="NOT_SAFE_TO_UPGRADE_NOT_ENOUGH_SPACE_PROBLEM" xml:space="preserve">
<value>However, there is not enough space to perform the repartitioning. To upgrade to {0}, the size of the local storage needs to be increased first.</value>
</data>
<data name="NOT_SAFE_TO_UPGRADE_NOT_ENOUGH_SPACE_WARNING" xml:space="preserve">
<value>However, there is not enough space to perform the repartitioning. The current partitioning scheme cannot be retained if you upgrade to {0} or above, so the size of the local storage needs to be increased first.</value>
</data>
<data name="NOT_SAFE_TO_UPGRADE_UTILITY_PARTITION" xml:space="preserve">
<value>A utility partition prevents repartitioning.</value>
</data>
<data name="NOT_SAFE_TO_UPGRADE_UTILITY_PARTITION_PROBLEM" xml:space="preserve">
<value>However, there is a utility partition present which prevents repartitioning. To upgrade to {0}, the utility partition must be removed.</value>
</data>
<data name="NOT_SAFE_TO_UPGRADE_UTILITY_PARTITION_WARNING" xml:space="preserve">
<value>However, there is a utility partition present which prevents repartitioning. The current partitioning scheme cannot be retained if you upgrade to {0} or above, so the existing utility partition must be removed first.</value>
</data>
<data name="NOT_SAFE_TO_UPGRADE_VDI_PRESENT" xml:space="preserve">
<value>VMs on local disk will prevent disk repartitioning.</value>
</data>
<data name="NOT_SAFE_TO_UPGRADE_VDI_PRESENT_PROBLEM" xml:space="preserve">
<value>However, there are VMs on local storage, so the new disk partitioning can not be applied. To upgrade to {0} or above, VMs must be moved from local storage first.</value>
</data>
<data name="NOT_SAFE_TO_UPGRADE_VDI_PRESENT_WARNING" xml:space="preserve">
<value>However, there are VMs on local storage, so the new partitioning scheme cannot be applied. To upgrade to {0} or above, or to benefit from repartitioning on upgrade to a version older than {0}, VMs must be moved from local storage first.</value>
</data>
<data name="NOT_TRUSTED" xml:space="preserve">
<value>not trusted</value>
@ -14612,4 +14640,4 @@ Any disk in your VM's DVD drive will be ejected when installing [Citrix VM Tools
<data name="YOU_ARE_HERE" xml:space="preserve">
<value>You are here</value>
</data>
</root>
</root>

16
XenModel/Utils/Helpers.cs
View File

@ -494,6 +494,22 @@ namespace XenAdmin.Core
{
return platformVersion != null && productVersionCompare(platformVersion, "3.1.50") >= 0;
}
/// <param name="conn">May be null, in which case true is returned.</param>
public static bool PostStockholm(IXenConnection conn)
{
return conn == null || PostStockholm(Helpers.GetMaster(conn));
}
/// <param name="host">May be null, in which case true is returned.</param>
public static bool PostStockholm(Host host)
{
return host == null || PostStockholm(HostPlatformVersion(host));
}
public static bool PostStockholm(string platformVersion)
{
return platformVersion != null && productVersionCompare(platformVersion, "3.2.50") >= 0;
}
// CP-3435: Disable Check for Updates in Common Criteria Certification project
public static bool CommonCriteriaCertificationRelease

2
scripts/hotfix-map.json
View File

@ -11,7 +11,7 @@
"flat": "true"
},
{
"pattern": "builds/xs/hotfixes/trunk/RPU005/1.0/RPU005.iso",
"pattern": "builds/xs/hotfixes/trunk/RPU005/2.0/RPU005.iso",
"target": "xenadmin.git/Branding/Hotfixes/RPU005.iso",
"flat": "true"
}