mirror of
https://github.com/xcp-ng/xenadmin.git
synced 2024-11-25 06:16:37 +01:00
798 lines
35 KiB
C#
798 lines
35 KiB
C#
/* 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.ComponentModel;
|
|
using System.Diagnostics;
|
|
using System.Linq;
|
|
using XenAdmin.Actions;
|
|
using XenAdmin.Alerts;
|
|
using XenAdmin.Alerts.Types;
|
|
using XenAdmin.Network;
|
|
using XenAPI;
|
|
|
|
|
|
namespace XenAdmin.Core
|
|
{
|
|
public class Updates
|
|
{
|
|
private static readonly log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
|
|
|
|
public static event Action CheckForUpdatesCompleted;
|
|
public static event Action CheckForUpdatesStarted;
|
|
public static event Action<CollectionChangeEventArgs> UpdateAlertCollectionChanged;
|
|
|
|
private static readonly object downloadedUpdatesLock = new object();
|
|
private static List<XenServerVersion> XenServerVersionsForAutoCheck = new List<XenServerVersion>();
|
|
private static List<XenServerPatch> XenServerPatches = new List<XenServerPatch>();
|
|
private static List<ClientVersion> ClientVersions = new List<ClientVersion>();
|
|
public static List<XenServerVersion> XenServerVersions = new List<XenServerVersion>();
|
|
|
|
private static readonly object updateAlertsLock = new object();
|
|
private static readonly List<Alert> updateAlerts = new List<Alert>();
|
|
|
|
/// <summary>
|
|
/// Locks and creates a new list of the update alerts
|
|
/// </summary>
|
|
public static List<Alert> UpdateAlerts
|
|
{
|
|
get
|
|
{
|
|
lock (updateAlertsLock)
|
|
return updateAlerts.ToList();
|
|
}
|
|
}
|
|
|
|
public static void RemoveUpdate(Alert update)
|
|
{
|
|
lock (updateAlertsLock)
|
|
updateAlerts.Remove(update);
|
|
|
|
UpdateAlertCollectionChanged?.Invoke(new CollectionChangeEventArgs(CollectionChangeAction.Remove, update));
|
|
}
|
|
|
|
/// <summary>
|
|
/// If AutomaticCheck is enabled it checks for updates regardless the
|
|
/// value of the parameter userRequested. If AutomaticCheck is disabled it checks
|
|
/// for all update types if userRequested is true.
|
|
/// </summary>
|
|
public static void CheckForUpdates(bool userRequested = false)
|
|
{
|
|
if (Helpers.CommonCriteriaCertificationRelease)
|
|
return;
|
|
|
|
if (Properties.Settings.Default.AllowXenCenterUpdates || userRequested)
|
|
{
|
|
string userAgent = $"{BrandManager.BrandConsole}/{BrandManager.XenCenterVersion}.{Program.Version.Revision} ({IntPtr.Size * 8}-bit)";
|
|
|
|
var action = new DownloadUpdatesXmlAction(Properties.Settings.Default.AllowXenCenterUpdates || userRequested,
|
|
false, false, userAgent, !userRequested);
|
|
action.Completed += actionCompleted;
|
|
|
|
CheckForUpdatesStarted?.Invoke();
|
|
|
|
action.RunAsync();
|
|
}
|
|
}
|
|
|
|
private static void actionCompleted(ActionBase sender)
|
|
{
|
|
Program.AssertOffEventThread();
|
|
|
|
if (!(sender is DownloadUpdatesXmlAction action))
|
|
return;
|
|
|
|
bool succeeded = action.Succeeded;
|
|
|
|
if (succeeded)
|
|
{
|
|
lock (downloadedUpdatesLock)
|
|
{
|
|
ClientVersions = action.ClientVersions;
|
|
XenServerVersionsForAutoCheck = action.XenServerVersionsForAutoCheck;
|
|
XenServerVersions = action.XenServerVersions;
|
|
XenServerPatches = action.XenServerPatches;
|
|
}
|
|
}
|
|
|
|
lock (updateAlertsLock)
|
|
{
|
|
updateAlerts.Clear();
|
|
|
|
if (succeeded)
|
|
{
|
|
var clientUpdateAlerts = NewClientUpdateAlerts(ClientVersions, Program.Version);
|
|
updateAlerts.AddRange(clientUpdateAlerts.Where(a => !a.IsDismissed()));
|
|
|
|
var xenServerUpdateAlerts = NewXenServerVersionAlerts(XenServerVersionsForAutoCheck);
|
|
updateAlerts.AddRange(xenServerUpdateAlerts.Where(a => !a.CanIgnore));
|
|
|
|
var xenServerPatchAlerts = NewXenServerPatchAlerts(XenServerVersions, XenServerPatches);
|
|
updateAlerts.AddRange(xenServerPatchAlerts.Where(a => !a.CanIgnore));
|
|
}
|
|
}
|
|
|
|
UpdateAlertCollectionChanged?.Invoke(new CollectionChangeEventArgs(CollectionChangeAction.Refresh, UpdateAlerts));
|
|
|
|
CheckForUpdatesCompleted?.Invoke();
|
|
}
|
|
|
|
public static List<ClientUpdateAlert> NewClientUpdateAlerts(List<ClientVersion> clientVersions,
|
|
Version currentProgramVersion)
|
|
{
|
|
if (Helpers.CommonCriteriaCertificationRelease)
|
|
return new List<ClientUpdateAlert>();
|
|
|
|
var alerts = new List<ClientUpdateAlert>();
|
|
ClientVersion latest = null, latestCr = null;
|
|
|
|
if (clientVersions.Count != 0 && currentProgramVersion != new Version(0, 0, 0, 0))
|
|
{
|
|
var latestVersions = from v in clientVersions where v.Latest select v;
|
|
latest = latestVersions.FirstOrDefault(xcv => xcv.Lang == Program.CurrentLanguage) ??
|
|
latestVersions.FirstOrDefault(xcv => string.IsNullOrEmpty(xcv.Lang));
|
|
|
|
if (IsSuitableForClientUpdateAlert(latest, currentProgramVersion))
|
|
alerts.Add(new ClientUpdateAlert(latest));
|
|
|
|
var latestCrVersions = from v in clientVersions where v.LatestCr select v;
|
|
latestCr = latestCrVersions.FirstOrDefault(xcv => xcv.Lang == Program.CurrentLanguage) ??
|
|
latestCrVersions.FirstOrDefault(xcv => string.IsNullOrEmpty(xcv.Lang));
|
|
|
|
if (latestCr != latest && IsSuitableForClientUpdateAlert(latestCr, currentProgramVersion))
|
|
alerts.Add(new ClientUpdateAlert(latestCr));
|
|
}
|
|
|
|
if (alerts.Count == 0)
|
|
{
|
|
log.InfoFormat("Not alerting XenCenter update - latest = {0}, latestcr = {1}, detected = {2}",
|
|
latest != null ? latest.VersionAndLang : "", latestCr != null ? latestCr.VersionAndLang : "", Program.VersionAndLanguage);
|
|
}
|
|
|
|
return alerts;
|
|
}
|
|
|
|
private static bool IsSuitableForClientUpdateAlert(ClientVersion toUse, Version currentProgramVersion)
|
|
{
|
|
if (toUse == null)
|
|
return false;
|
|
|
|
if (!toUse.Name.Contains(BrandManager.BrandConsole))
|
|
return false;
|
|
|
|
return toUse.Version > currentProgramVersion ||
|
|
toUse.Version == currentProgramVersion && toUse.Lang == Program.CurrentLanguage &&
|
|
!FriendlyNameManager.IsCultureLoaded(Program.CurrentCulture);
|
|
}
|
|
|
|
public static List<XenServerPatchAlert> NewXenServerPatchAlerts(List<XenServerVersion> xenServerVersions,
|
|
List<XenServerPatch> xenServerPatches)
|
|
{
|
|
if (Helpers.CommonCriteriaCertificationRelease)
|
|
return new List<XenServerPatchAlert>();
|
|
|
|
var alerts = new List<XenServerPatchAlert>();
|
|
|
|
var xenServerVersionsAsUpdates = xenServerVersions.Where(v => v.IsVersionAvailableAsAnUpdate);
|
|
|
|
foreach (IXenConnection xenConnection in ConnectionsManager.XenConnectionsCopy)
|
|
{
|
|
Host coordinator = Helpers.GetCoordinator(xenConnection);
|
|
Pool pool = Helpers.GetPoolOfOne(xenConnection);
|
|
List<Host> hosts = xenConnection.Cache.Hosts.ToList();
|
|
if (coordinator == null || pool == null)
|
|
continue;
|
|
|
|
var serverVersions = new List<XenServerVersion>();
|
|
foreach (Host host in hosts)
|
|
{
|
|
var serverVersion = GetServerVersions(host, xenServerVersions);
|
|
serverVersions.AddRange(serverVersion);
|
|
}
|
|
serverVersions = serverVersions.Distinct().ToList();
|
|
|
|
if (serverVersions.Count == 0)
|
|
continue;
|
|
|
|
foreach (XenServerVersion xenServerVersion in serverVersions)
|
|
{
|
|
XenServerVersion version = xenServerVersion;
|
|
List<XenServerPatch> patches = xenServerPatches.FindAll(patch => version.Patches.Contains(patch));
|
|
|
|
if (patches.Count == 0)
|
|
continue;
|
|
|
|
foreach (XenServerPatch xenServerPatch in patches)
|
|
{
|
|
XenServerVersion newServerVersion = xenServerVersionsAsUpdates.FirstOrDefault(newVersion => newVersion.PatchUuid.Equals(xenServerPatch.Uuid, StringComparison.OrdinalIgnoreCase));
|
|
|
|
var alert = new XenServerPatchAlert(xenServerPatch, newServerVersion);
|
|
var existingAlert = alerts.Find(al => al.Equals(alert));
|
|
|
|
if (existingAlert != null)
|
|
alert = existingAlert;
|
|
else
|
|
alerts.Add(alert);
|
|
|
|
if (!xenConnection.IsConnected)
|
|
continue;
|
|
|
|
XenServerPatch serverPatch = xenServerPatch;
|
|
|
|
var noPatchHosts = hosts.Where(host => PatchCanBeInstalledOnHost(serverPatch, host)).ToList();
|
|
|
|
if (noPatchHosts.Count == hosts.Count)
|
|
alert.IncludeConnection(xenConnection);
|
|
else
|
|
alert.IncludeHosts(noPatchHosts);
|
|
}
|
|
}
|
|
}
|
|
|
|
return alerts;
|
|
}
|
|
|
|
private static bool PatchCanBeInstalledOnHost(XenServerPatch serverPatch, Host host)
|
|
{
|
|
Debug.Assert(serverPatch != null);
|
|
Debug.Assert(host != null);
|
|
|
|
// A patch is applicable to host if the patch is amongst the current version patches
|
|
var patchIsApplicable = GetServerVersions(host, XenServerVersions).Any(v => v.Patches.Contains(serverPatch));
|
|
if (!patchIsApplicable)
|
|
return false;
|
|
|
|
// A patch can be installed on a host if:
|
|
// 1. it is not already installed and
|
|
// 2. the host has all the required patches installed and
|
|
// 3. the host doesn't have any of the conflicting patches installed
|
|
|
|
bool elyOrGreater = Helpers.ElyOrGreater(host);
|
|
var appliedUpdates = host.AppliedUpdates();
|
|
var appliedPatches = host.AppliedPatches();
|
|
|
|
// 1. patch is not already installed
|
|
if (elyOrGreater && appliedUpdates.Any(update => string.Equals(update.uuid, serverPatch.Uuid, StringComparison.OrdinalIgnoreCase)))
|
|
return false;
|
|
if (!elyOrGreater && appliedPatches.Any(patch => string.Equals(patch.uuid, serverPatch.Uuid, StringComparison.OrdinalIgnoreCase)))
|
|
return false;
|
|
|
|
// 2. the host has all the required patches installed
|
|
if (serverPatch.RequiredPatches != null && serverPatch.RequiredPatches.Count > 0 &&
|
|
!serverPatch.RequiredPatches
|
|
.All(requiredPatchUuid =>
|
|
elyOrGreater && appliedUpdates.Any(update => string.Equals(update.uuid, requiredPatchUuid, StringComparison.OrdinalIgnoreCase))
|
|
|| !elyOrGreater && appliedPatches.Any(patch => string.Equals(patch.uuid, requiredPatchUuid, StringComparison.OrdinalIgnoreCase))
|
|
)
|
|
)
|
|
return false;
|
|
|
|
// 3. the host doesn't have any of the conflicting patches installed
|
|
if (serverPatch.ConflictingPatches != null && serverPatch.ConflictingPatches.Count > 0 &&
|
|
serverPatch.ConflictingPatches
|
|
.Any(conflictingPatchUuid =>
|
|
elyOrGreater && appliedUpdates.Any(update => string.Equals(update.uuid, conflictingPatchUuid, StringComparison.OrdinalIgnoreCase))
|
|
|| !elyOrGreater && appliedPatches.Any(patch => string.Equals(patch.uuid, conflictingPatchUuid, StringComparison.OrdinalIgnoreCase))
|
|
)
|
|
)
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// If parameter is null, it returns latestcr XenCenter version if it is greater than current XC version,
|
|
/// or null, if the current XC version is latestcr.
|
|
/// If parameter is not null, it returns the minimum XenCenter version if it is greater than the current XC version,
|
|
/// or null, if the minimum XC version couldn't be found or the current XC version is enough.
|
|
/// </summary>
|
|
public static ClientVersion GetRequiredClientVersion(XenServerVersion serverVersion)
|
|
{
|
|
if (ClientVersions.Count == 0)
|
|
return null;
|
|
|
|
var currentProgramVersion = Program.Version;
|
|
if (currentProgramVersion == new Version(0, 0, 0, 0))
|
|
return null;
|
|
|
|
if (serverVersion == null)
|
|
return ClientVersions.FirstOrDefault(xcv => xcv.LatestCr && xcv.Version > currentProgramVersion);
|
|
|
|
var minXcVersion = serverVersion.MinimumXcVersion;
|
|
if (minXcVersion == null)
|
|
return null;
|
|
|
|
var minimumXcVersion = ClientVersions.FirstOrDefault(xcv => xcv.Version == minXcVersion);
|
|
return minimumXcVersion != null && minimumXcVersion.Version > currentProgramVersion
|
|
? minimumXcVersion
|
|
: null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// This method returns the minimal set of patches for a host if this class already has information about them.
|
|
/// Otherwise it returns empty list.
|
|
/// Calling this function will not initiate a download or update.
|
|
/// </summary>
|
|
public static List<XenServerPatch> RecommendedPatchesForHost(Host host)
|
|
{
|
|
var recommendedPatches = new List<XenServerPatch>();
|
|
|
|
if (XenServerVersions == null)
|
|
return null;
|
|
|
|
var serverVersions = GetServerVersions(host, XenServerVersions);
|
|
|
|
if (serverVersions.Count != 0)
|
|
{
|
|
var minimumPatches = serverVersions[0].MinimalPatches;
|
|
|
|
if (minimumPatches == null) //unknown
|
|
return null;
|
|
|
|
bool elyOrGreater = Helpers.ElyOrGreater(host);
|
|
|
|
var appliedPatches = host.AppliedPatches();
|
|
var appliedUpdates = host.AppliedUpdates();
|
|
|
|
if (elyOrGreater)
|
|
{
|
|
recommendedPatches = minimumPatches.FindAll(p => !appliedUpdates.Any(au => string.Equals(au.uuid, p.Uuid, StringComparison.OrdinalIgnoreCase)));
|
|
}
|
|
else
|
|
{
|
|
recommendedPatches = minimumPatches.FindAll(p => !appliedPatches.Any(ap => string.Equals(ap.uuid, p.Uuid, StringComparison.OrdinalIgnoreCase)));
|
|
}
|
|
|
|
}
|
|
|
|
return recommendedPatches;
|
|
}
|
|
|
|
public static List<XenServerPatch> GetMinimalPatches(IXenConnection conn)
|
|
{
|
|
var version = GetCommonServerVersionOfHostsInAConnection(conn, XenServerVersions);
|
|
return GetMinimalPatches(version);
|
|
}
|
|
|
|
public static List<XenServerPatch> GetMinimalPatches(Host host)
|
|
{
|
|
if (host == null || host.Connection == null || XenServerVersions== null)
|
|
return null;
|
|
var hostVersions = GetServerVersions(host, XenServerVersions);
|
|
return GetMinimalPatches(hostVersions.FirstOrDefault());
|
|
}
|
|
|
|
private static List<XenServerPatch> GetMinimalPatches(XenServerVersion version)
|
|
{
|
|
if (version == null || version.MinimalPatches == null)
|
|
return null;
|
|
|
|
var minimalPatches = new List<XenServerPatch>(version.MinimalPatches);
|
|
|
|
// if there is a "new version" update in the update sequence, also add the minimal patches of this new version
|
|
if (minimalPatches.Count > 0)
|
|
{
|
|
// assuming that the new version update (if there is one) is the last one in the minimal patches list
|
|
var lastUpdate = minimalPatches[minimalPatches.Count - 1];
|
|
|
|
var newServerVersion = XenServerVersions.FirstOrDefault(
|
|
v => v.IsVersionAvailableAsAnUpdate && v.PatchUuid.Equals(lastUpdate.Uuid, StringComparison.OrdinalIgnoreCase));
|
|
|
|
if (newServerVersion != null && newServerVersion.MinimalPatches != null)
|
|
minimalPatches.AddRange(newServerVersion.MinimalPatches);
|
|
}
|
|
|
|
return minimalPatches;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets an upgrade sequence that contains a version upgrade, optionally followed by the minimal patches for the new version
|
|
/// </summary>
|
|
/// <param name="alert">The alert that refers the version-update</param>
|
|
/// <param name="updateTheNewVersion">Also add the minimum patches for the new version (true) or not (false).</param>
|
|
public static List<XenServerPatch> GetMinimalPatches(XenServerPatchAlert alert, bool updateTheNewVersion)
|
|
{
|
|
Debug.Assert(alert != null);
|
|
|
|
var minimalPatches = new List<XenServerPatch> {alert.Patch};
|
|
|
|
// if it's a version upgrade the min sequence will be this patch (the upgrade) and the min patches for the new version
|
|
if (updateTheNewVersion && alert.NewServerVersion != null && alert.NewServerVersion.MinimalPatches != null)
|
|
{
|
|
minimalPatches.AddRange(alert.NewServerVersion.MinimalPatches);
|
|
}
|
|
|
|
return minimalPatches;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets all the patches for the given connection
|
|
/// </summary>
|
|
public static List<XenServerPatch> GetAllPatches(IXenConnection conn)
|
|
{
|
|
var version = GetCommonServerVersionOfHostsInAConnection(conn, XenServerVersions);
|
|
return GetAllPatches(version);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets an upgrade sequence that contains a version upgrade, optionally followed by all the patches for the new version
|
|
/// </summary>
|
|
public static List<XenServerPatch> GetAllPatches(XenServerPatchAlert alert, bool updateTheNewVersion)
|
|
{
|
|
Debug.Assert(alert != null);
|
|
|
|
var allPatches = new List<XenServerPatch> { alert.Patch };
|
|
|
|
// if it's a version upgrade the update sequence will be this patch (the upgrade) and the patches for the new version
|
|
if (updateTheNewVersion && alert.NewServerVersion != null)
|
|
{
|
|
var newVersionPatches = GetAllPatches(alert.NewServerVersion);
|
|
if (newVersionPatches != null)
|
|
allPatches.AddRange(newVersionPatches);
|
|
}
|
|
|
|
return allPatches;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets all the patches for the given server version, including the cumulative updates and the patches on those
|
|
/// </summary>
|
|
private static List<XenServerPatch> GetAllPatches(XenServerVersion version)
|
|
{
|
|
if (version == null || version.Patches == null)
|
|
return null;
|
|
|
|
// exclude patches that are new versions (we will include the cumulative updates later)
|
|
var excludedUuids = XenServerVersions.Where(v => v.IsVersionAvailableAsAnUpdate).Select(v => v.PatchUuid);
|
|
|
|
var allPatches = new List<XenServerPatch>(version.Patches.Where(p => !excludedUuids.Contains(p.Uuid)));
|
|
|
|
// if there is a "new version" update in the minimal patches (e.g. a cumulative update), also add this new version update and all the patches on it
|
|
if (version.MinimalPatches != null && version.MinimalPatches.Count > 0)
|
|
{
|
|
// assuming that the new version update (if there is one) is the last one in the minimal patches list
|
|
var lastUpdate = version.MinimalPatches[version.MinimalPatches.Count - 1];
|
|
|
|
var newServerVersion = XenServerVersions.FirstOrDefault(
|
|
v => v.IsVersionAvailableAsAnUpdate && v.PatchUuid.Equals(lastUpdate.Uuid, StringComparison.OrdinalIgnoreCase));
|
|
|
|
if (newServerVersion != null)
|
|
{
|
|
allPatches.Add(lastUpdate);
|
|
if (newServerVersion.Patches != null)
|
|
allPatches.AddRange(newServerVersion.Patches);
|
|
}
|
|
}
|
|
|
|
return allPatches;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a XenServerVersion if all hosts of the pool have the same version
|
|
/// Returns null if it is unknown or they don't match
|
|
/// </summary>
|
|
private static XenServerVersion GetCommonServerVersionOfHostsInAConnection(IXenConnection connection, List<XenServerVersion> xsVersions)
|
|
{
|
|
if (connection == null || xsVersions == null)
|
|
return null;
|
|
|
|
XenServerVersion commonXenServerVersion = null;
|
|
List<Host> hosts = connection.Cache.Hosts.ToList();
|
|
|
|
foreach (Host host in hosts)
|
|
{
|
|
var hostVersions = GetServerVersions(host, xsVersions);
|
|
|
|
var foundVersion = hostVersions.FirstOrDefault();
|
|
|
|
if (foundVersion == null)
|
|
{
|
|
return null;
|
|
}
|
|
else
|
|
{
|
|
if (commonXenServerVersion == null)
|
|
{
|
|
commonXenServerVersion = foundVersion;
|
|
}
|
|
else
|
|
{
|
|
if (commonXenServerVersion != foundVersion)
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
return commonXenServerVersion;
|
|
}
|
|
|
|
public static List<XenServerPatch> GetPatchSequenceForHost(Host h, List<XenServerPatch> minimalPatches)
|
|
{
|
|
if (minimalPatches == null)
|
|
return null;
|
|
|
|
var appliedUpdateUuids = Helpers.ElyOrGreater(h)
|
|
? h.AppliedUpdates().Select(u => u.uuid).ToList()
|
|
: h.AppliedPatches().Select(p => p.uuid).ToList();
|
|
|
|
var neededPatches = new List<XenServerPatch>(minimalPatches);
|
|
var sequence = new List<XenServerPatch>();
|
|
|
|
//Iterate through minimalPatches once; in each iteration, move the first item from L0
|
|
//that has its dependencies met to the end of the update schedule
|
|
for (int i = 0; i < neededPatches.Count; i++)
|
|
{
|
|
var p = neededPatches[i];
|
|
|
|
if (appliedUpdateUuids.Any(apu => string.Equals(apu, p.Uuid, StringComparison.OrdinalIgnoreCase)))
|
|
continue; //the patch has been applied
|
|
|
|
if (p.RequiredPatches == null || p.RequiredPatches.Count == 0 // no requirements
|
|
|| p.RequiredPatches.All(rp => //all the required patches are already in the sequence or have already been applied
|
|
sequence.Any(useqp => string.Equals(useqp.Uuid, rp, StringComparison.OrdinalIgnoreCase))
|
|
|| appliedUpdateUuids.Any(apu => string.Equals(apu, rp, StringComparison.OrdinalIgnoreCase))
|
|
)
|
|
)
|
|
{
|
|
// this patch can be added to the upgrade sequence now
|
|
sequence.Add(p);
|
|
|
|
// by now the patch has either been added to the upgrade sequence or something already contains it among the installed patches
|
|
neededPatches.RemoveAt(i);
|
|
|
|
//resetting position - the loop will start on 0. item
|
|
i = -1;
|
|
}
|
|
}
|
|
|
|
return sequence;
|
|
}
|
|
|
|
public static List<XenServerVersionAlert> NewXenServerVersionAlerts(List<XenServerVersion> xenServerVersions)
|
|
{
|
|
if (Helpers.CommonCriteriaCertificationRelease)
|
|
return new List<XenServerVersionAlert>();
|
|
|
|
var latestVersion = xenServerVersions.FindAll(item => item.Latest).OrderByDescending(v => v.Version).FirstOrDefault();
|
|
var latestCrVersion = xenServerVersions.FindAll(item => item.LatestCr).OrderByDescending(v => v.Version).FirstOrDefault();
|
|
|
|
List<XenServerVersionAlert> alerts = new List<XenServerVersionAlert>();
|
|
|
|
if (latestVersion != null)
|
|
alerts.Add(CreateAlertForXenServerVersion(latestVersion));
|
|
|
|
if (latestCrVersion != null && latestCrVersion != latestVersion)
|
|
alerts.Add(CreateAlertForXenServerVersion(latestCrVersion));
|
|
|
|
return alerts;
|
|
}
|
|
|
|
private static XenServerVersionAlert CreateAlertForXenServerVersion(XenServerVersion version)
|
|
{
|
|
var alert = new XenServerVersionAlert(version);
|
|
|
|
// the patch that installs this version, if any
|
|
var patch = XenServerPatches.FirstOrDefault(p => p.Uuid.Equals(version.PatchUuid, StringComparison.OrdinalIgnoreCase));
|
|
|
|
foreach (IXenConnection xc in ConnectionsManager.XenConnectionsCopy)
|
|
{
|
|
if (!xc.IsConnected)
|
|
continue;
|
|
|
|
Host coordinator = Helpers.GetCoordinator(xc);
|
|
Pool pool = Helpers.GetPoolOfOne(xc);
|
|
List<Host> hosts = xc.Cache.Hosts.ToList();
|
|
if (coordinator == null || pool == null)
|
|
continue;
|
|
|
|
// Show the Upgrade alert for a host if:
|
|
// - the host version is older than this version AND
|
|
// - there is no patch (amongst the current version patches) that can update to this version OR, if there is a patch, the patch cannot be installed
|
|
|
|
var outOfDateHosts = hosts.Where(host => new Version(Helpers.HostProductVersion(host)) < version.Version
|
|
&& (patch == null || !PatchCanBeInstalledOnHost(patch, host))).ToList();
|
|
|
|
if (outOfDateHosts.Count == hosts.Count)
|
|
alert.IncludeConnection(xc);
|
|
else
|
|
alert.IncludeHosts(outOfDateHosts);
|
|
}
|
|
|
|
return alert;
|
|
}
|
|
|
|
public static List<XenServerVersion> GetServerVersions(Host host, List<XenServerVersion> xenServerVersions)
|
|
{
|
|
var serverVersions = xenServerVersions.FindAll(version =>
|
|
{
|
|
if (version.BuildNumber != string.Empty)
|
|
return (host.BuildNumberRaw() == version.BuildNumber);
|
|
|
|
return Helpers.HostProductVersion(host) == version.Version.ToString();
|
|
});
|
|
return serverVersions;
|
|
}
|
|
|
|
public static void RefreshUpdateAlerts(UpdateType flags)
|
|
{
|
|
var alerts = new List<XenServerUpdateAlert>();
|
|
|
|
if (flags.HasFlag(UpdateType.ServerVersion))
|
|
alerts.AddRange(NewXenServerVersionAlerts(XenServerVersionsForAutoCheck));
|
|
|
|
if (flags.HasFlag(UpdateType.ServerPatches))
|
|
alerts.AddRange(NewXenServerPatchAlerts(XenServerVersions, XenServerPatches));
|
|
|
|
bool changed = false;
|
|
|
|
try
|
|
{
|
|
lock (updateAlertsLock)
|
|
{
|
|
foreach (var alert in alerts)
|
|
{
|
|
var existingAlert = updateAlerts.FirstOrDefault(a => a.Equals(alert));
|
|
|
|
if (existingAlert != null && alert.CanIgnore)
|
|
{
|
|
updateAlerts.Remove(existingAlert);
|
|
changed = true;
|
|
}
|
|
else if (existingAlert is XenServerUpdateAlert updAlert)
|
|
{
|
|
updateAlerts.Remove(updAlert);
|
|
updAlert.CopyConnectionsAndHosts(alert);
|
|
if (!updateAlerts.Contains(updAlert))
|
|
updateAlerts.Add(updAlert);
|
|
changed = true;
|
|
}
|
|
else if (!alert.CanIgnore && !updateAlerts.Contains(alert))
|
|
{
|
|
updateAlerts.Add(alert);
|
|
changed = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (changed)
|
|
UpdateAlertCollectionChanged?.Invoke(new CollectionChangeEventArgs(CollectionChangeAction.Refresh, UpdateAlerts));
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
log.Error("Failed to refresh the updates", e);
|
|
}
|
|
}
|
|
|
|
private static XenServerPatchAlert FindPatchAlert(Predicate<XenServerPatch> predicate)
|
|
{
|
|
var existingAlert = UpdateAlerts.FirstOrDefault(a => a is XenServerPatchAlert patchAlert && predicate(patchAlert.Patch));
|
|
if (existingAlert != null)
|
|
return existingAlert as XenServerPatchAlert;
|
|
|
|
if (XenServerPatches.Count == 0)
|
|
return null;
|
|
|
|
var xenServerPatch = XenServerPatches.FirstOrDefault(p => predicate(p));
|
|
if (xenServerPatch == null)
|
|
return null;
|
|
|
|
var newServerVersion = XenServerVersions.FirstOrDefault(v => v.IsVersionAvailableAsAnUpdate &&
|
|
v.PatchUuid.Equals(xenServerPatch.Uuid, StringComparison.OrdinalIgnoreCase));
|
|
|
|
return new XenServerPatchAlert(xenServerPatch, newServerVersion);
|
|
}
|
|
|
|
public static XenServerPatchAlert FindPatchAlertByUuid(string uuid)
|
|
{
|
|
if (string.IsNullOrEmpty(uuid))
|
|
return null;
|
|
return FindPatchAlert(p => p.Uuid.Equals(uuid, StringComparison.OrdinalIgnoreCase));
|
|
}
|
|
|
|
public static XenServerPatchAlert FindPatchAlertByName(string patchName)
|
|
{
|
|
if (string.IsNullOrEmpty(patchName))
|
|
return null;
|
|
return FindPatchAlert(p => p.Name.Equals(patchName, StringComparison.OrdinalIgnoreCase));
|
|
}
|
|
|
|
public static hotfix_eligibility HotfixEligibility(Host host, out XenServerVersion xenServerVersion)
|
|
{
|
|
xenServerVersion = null;
|
|
if (XenServerVersions == null)
|
|
return hotfix_eligibility.all;
|
|
|
|
xenServerVersion = GetServerVersions(host, XenServerVersions).FirstOrDefault();
|
|
|
|
return xenServerVersion?.HotfixEligibility ?? hotfix_eligibility.all;
|
|
}
|
|
|
|
public static void CheckHotfixEligibility(IXenConnection connection)
|
|
{
|
|
var coordinator = Helpers.GetCoordinator(connection);
|
|
if (coordinator == null)
|
|
return;
|
|
|
|
var hotfixEligibility = HotfixEligibility(coordinator, out var xenServerVersion);
|
|
|
|
if (!HotfixEligibilityAlert.IsAlertNeeded(hotfixEligibility, xenServerVersion, !coordinator.IsFreeLicenseOrExpired()))
|
|
{
|
|
Alert.RemoveAlert(a => a is HotfixEligibilityAlert && connection.Equals(a.Connection));
|
|
return;
|
|
}
|
|
|
|
var alertIndex = Alert.FindAlertIndex(a => a is HotfixEligibilityAlert alert && connection.Equals(alert.Connection) && xenServerVersion == alert.Version);
|
|
if (alertIndex == -1)
|
|
{
|
|
Alert.RemoveAlert(a => a is HotfixEligibilityAlert && connection.Equals(a.Connection)); // ensure that there is no other alert for this connection
|
|
Alert.AddAlert(new HotfixEligibilityAlert(connection, xenServerVersion));
|
|
}
|
|
else
|
|
Alert.RefreshAlertAt(alertIndex);
|
|
}
|
|
|
|
public static void CheckHotfixEligibility()
|
|
{
|
|
var alerts = new List<HotfixEligibilityAlert>();
|
|
|
|
foreach (var connection in ConnectionsManager.XenConnectionsCopy)
|
|
{
|
|
if (!connection.IsConnected)
|
|
continue;
|
|
|
|
var coordinator = Helpers.GetCoordinator(connection);
|
|
if (coordinator == null)
|
|
continue;
|
|
|
|
var hotfixEligibility = HotfixEligibility(coordinator, out var xenServerVersion);
|
|
if (!HotfixEligibilityAlert.IsAlertNeeded(hotfixEligibility, xenServerVersion, !coordinator.IsFreeLicenseOrExpired()))
|
|
continue;
|
|
|
|
alerts.Add(new HotfixEligibilityAlert(connection, xenServerVersion));
|
|
}
|
|
|
|
Alert.RemoveAlert(a => a is HotfixEligibilityAlert);
|
|
Alert.AddAlertRange(alerts);
|
|
}
|
|
|
|
[Flags]
|
|
public enum UpdateType : short
|
|
{
|
|
None = 0,
|
|
ServerPatches = 1,
|
|
ServerVersion = 2,
|
|
XenCenterVersion = 4
|
|
}
|
|
}
|
|
}
|