mirror of
https://github.com/xcp-ng/xenadmin.git
synced 2024-12-21 07:56:03 +01:00
2147 lines
78 KiB
C#
Executable File
2147 lines
78 KiB
C#
Executable File
/* 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.Linq;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using System.IO;
|
|
using XenAdmin.Network;
|
|
|
|
using XenAPI;
|
|
using System.Globalization;
|
|
using System.Reflection;
|
|
using System.Xml;
|
|
using System.Diagnostics;
|
|
|
|
|
|
namespace XenAdmin.Core
|
|
{
|
|
public static class Helpers
|
|
{
|
|
private static readonly log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
|
|
|
|
private const long XLVHD_DEF_ALLOCATION_QUANTUM_DIVISOR = 10000;
|
|
public const long XLVHD_MIN_ALLOCATION_QUANTUM_DIVISOR = 50000;
|
|
public const long XLVHD_MAX_ALLOCATION_QUANTUM_DIVISOR = 4000;
|
|
public const long XLVHD_MIN_ALLOCATION_QUANTUM = 16777216; // 16 MB
|
|
|
|
public const int DEFAULT_NAME_TRIM_LENGTH = 50;
|
|
|
|
public const string GuiTempObjectPrefix = "__gui__";
|
|
|
|
public const int CUSTOM_BUILD_NUMBER = 6666;
|
|
|
|
public static NumberFormatInfo _nfi = new CultureInfo("en-US", false).NumberFormat;
|
|
|
|
public static readonly Regex SessionRefRegex = new Regex(@"OpaqueRef:[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}");
|
|
|
|
|
|
/// <summary>
|
|
/// Determine if the given URL represents a simulator db proxy
|
|
/// </summary>
|
|
/// <param name="url"></param>
|
|
/// <returns></returns>
|
|
public static bool DbProxyIsSimulatorUrl(string url)
|
|
{
|
|
return url.EndsWith(".db") || url.EndsWith(".xml") || url.EndsWith(".tmp");
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return the build number of the given host, or the build number of the master if the
|
|
/// given host does not have a build number, or -1 if we can't find one. This will often be
|
|
/// 0 or -1 for developer builds, so comparisons should generally treat those numbers as if
|
|
/// they were brand new.
|
|
/// </summary>
|
|
public static int HostBuildNumber(Host host)
|
|
{
|
|
if (host.BuildNumber <= 0)
|
|
{
|
|
Host master = GetMaster(host.Connection);
|
|
return master == null ? -1 : master.BuildNumber;
|
|
}
|
|
else
|
|
{
|
|
return host.BuildNumber;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return the given host's product version, or the pool master's product version if
|
|
/// the host does not have one, or null if none can be found.
|
|
/// </summary>
|
|
/// <param name="Host">May be null.</param>
|
|
public static string HostProductVersion(Host host)
|
|
{
|
|
return FromHostOrMaster(host, h => h.ProductVersion);
|
|
}
|
|
|
|
public static string HostProductVersionText(Host host)
|
|
{
|
|
return FromHostOrMaster(host, h => h.ProductVersionText);
|
|
}
|
|
|
|
public static string HostProductVersionTextShort(Host host)
|
|
{
|
|
return FromHostOrMaster(host, h => h.ProductVersionTextShort);
|
|
}
|
|
|
|
public static string HostPlatformVersion(Host host)
|
|
{
|
|
if (host == null)
|
|
return null;
|
|
|
|
return host.PlatformVersion;
|
|
}
|
|
|
|
private delegate string HostToStr(Host host);
|
|
private static string FromHostOrMaster(Host host, HostToStr fn)
|
|
{
|
|
if (host == null)
|
|
return null;
|
|
|
|
string output = fn(host);
|
|
|
|
if (output == null)
|
|
{
|
|
Host master = GetMaster(host.Connection);
|
|
return master == null ? null : fn(master);
|
|
}
|
|
|
|
return output;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Only log the unrecognised version message once (CA-11201).
|
|
/// </summary>
|
|
private static bool _unrecognisedVersionWarned = false;
|
|
/// <summary>
|
|
/// Numbers should have three parts, i.e. be in the form a.b.c, otherwise they won't be parsed.
|
|
/// </summary>
|
|
/// <param name="version1">May be null.</param>
|
|
/// <param name="version2">May be null.</param>
|
|
/// <returns></returns>
|
|
public static int productVersionCompare(string version1, string version2)
|
|
{
|
|
// Assume version numbers are of form 'a.b.c'
|
|
int a1 = 99, b1 = 99, c1 = 99, a2 = 99, b2 = 99, c2 = 99;
|
|
|
|
|
|
string[] tokens = null;
|
|
if (version1 != null)
|
|
tokens = version1.Split('.');
|
|
if (tokens != null && tokens.Length == 3)
|
|
{
|
|
a1 = int.Parse(tokens[0]);
|
|
b1 = int.Parse(tokens[1]);
|
|
c1 = int.Parse(tokens[2]);
|
|
}
|
|
else
|
|
{
|
|
if (!_unrecognisedVersionWarned)
|
|
{
|
|
log.DebugFormat("Unrecognised version format {0} - treating as developer version", version1);
|
|
_unrecognisedVersionWarned = true;
|
|
}
|
|
}
|
|
tokens = null;
|
|
if (version2 != null)
|
|
tokens = version2.Split('.');
|
|
if (tokens != null && tokens.Length == 3)
|
|
{
|
|
a2 = int.Parse(tokens[0]);
|
|
b2 = int.Parse(tokens[1]);
|
|
c2 = int.Parse(tokens[2]);
|
|
}
|
|
else
|
|
{
|
|
if (!_unrecognisedVersionWarned)
|
|
{
|
|
log.DebugFormat("Unrecognised version format {0} - treating as developer version", version2);
|
|
_unrecognisedVersionWarned = true;
|
|
}
|
|
}
|
|
|
|
if (a2 > a1)
|
|
{
|
|
return -1;
|
|
}
|
|
else if (a2 == a1)
|
|
{
|
|
if (b2 > b1)
|
|
{
|
|
return -1;
|
|
}
|
|
else if (b2 == b1)
|
|
{
|
|
if (c2 > c1)
|
|
{
|
|
return -1;
|
|
}
|
|
else if (c1 == c2)
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the pool for the provided connection. Returns null if we have
|
|
/// a standalone host (or the provided connection is null).
|
|
/// </summary>
|
|
/// <remarks> To obtain the pool object for the case of a standalone host
|
|
/// use GetPoolOfOne.</remarks>
|
|
public static Pool GetPool(IXenConnection connection)
|
|
{
|
|
if (connection == null)
|
|
return null;
|
|
|
|
foreach (Pool thePool in connection.Cache.Pools)
|
|
{
|
|
if (thePool != null && thePool.IsVisible)
|
|
return thePool;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Get the unique Pool object corresponding to the given connection.
|
|
/// Returns the pool object even in the case of a standalone host. May
|
|
/// return null if the cache is still being populated or the given
|
|
/// connection is null.
|
|
/// </summary>
|
|
public static Pool GetPoolOfOne(IXenConnection connection)
|
|
{
|
|
if (connection == null)
|
|
return null;
|
|
|
|
foreach (Pool pool in connection.Cache.Pools)
|
|
return pool;
|
|
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return the host object representing the master of the given connection, or null if the
|
|
/// cache is being populated.
|
|
/// </summary>
|
|
/// <param name="connection">May not be null.</param>
|
|
/// <returns></returns>
|
|
public static Host GetMaster(IXenConnection connection)
|
|
{
|
|
Pool pool = GetPoolOfOne(connection);
|
|
return pool == null ? null : connection.Resolve(pool.master);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return the host object representing the master of the given pool.
|
|
/// (If pool is null, returns null).
|
|
/// </summary>
|
|
public static Host GetMaster(Pool pool)
|
|
{
|
|
return pool == null ? null : pool.Connection.Resolve(pool.master);
|
|
}
|
|
|
|
public static bool HostIsMaster(Host host)
|
|
{
|
|
Pool pool = Helpers.GetPoolOfOne(host.Connection);
|
|
if (pool == null) //Cache is being populated... what do we do?
|
|
return false;
|
|
return host.opaque_ref == pool.master.opaque_ref;
|
|
}
|
|
|
|
public static bool IsPool(IXenConnection connection)
|
|
{
|
|
return (GetPool(connection) != null);
|
|
}
|
|
|
|
/// <param name="pool">May be null, in which case the empty string is returned.</param>
|
|
public static string GetName(Pool pool)
|
|
{
|
|
if (pool == null)
|
|
return "";
|
|
return pool.Name;
|
|
}
|
|
|
|
/// <param name="connection">May be null, in which case the empty string is returned.</param>
|
|
public static string GetName(IXenConnection connection)
|
|
{
|
|
return connection == null ? "" : connection.Name;
|
|
}
|
|
|
|
/// <param name="o">May be null, in which case the empty string is returned.</param>
|
|
public static string GetName(IXenObject o)
|
|
{
|
|
if (o == null)
|
|
return "";
|
|
return o.Name;
|
|
}
|
|
|
|
public static bool IsConnected(IXenConnection connection)
|
|
{
|
|
return (connection == null ? false : connection.IsConnected);
|
|
}
|
|
|
|
public static bool IsConnected(Pool pool)
|
|
{
|
|
return (pool == null ? false : IsConnected(pool.Connection));
|
|
}
|
|
|
|
public static bool IsConnected(Host host)
|
|
{
|
|
return (host == null ? false : IsConnected(host.Connection));
|
|
}
|
|
|
|
public static bool HasFullyConnectedSharedStorage(IXenConnection connection)
|
|
{
|
|
foreach (SR sr in connection.Cache.SRs)
|
|
{
|
|
if (sr.content_type != XenAPI.SR.Content_Type_ISO && sr.shared && sr.CanCreateVmOn())
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/// <param name="conn">May be null, in which case true is returned.</param>
|
|
public static bool TampaOrGreater(IXenConnection conn)
|
|
{
|
|
return conn == null ? true : TampaOrGreater(Helpers.GetMaster(conn));
|
|
}
|
|
|
|
/// <param name="host">May be null, in which case true is returned.</param>
|
|
public static bool TampaOrGreater(Host host)
|
|
{
|
|
if (host == null)
|
|
return true;
|
|
|
|
string platform_version = Helpers.HostPlatformVersion(host);
|
|
return
|
|
platform_version != null && Helpers.productVersionCompare(platform_version, "1.5.50") >= 0 ||
|
|
Helpers.HostBuildNumber(host) == CUSTOM_BUILD_NUMBER;
|
|
}
|
|
|
|
public static bool SanibelOrGreater(IXenConnection conn)
|
|
{
|
|
return conn == null ? true : SanibelOrGreater(Helpers.GetMaster(conn));
|
|
}
|
|
|
|
public static bool SanibelOrGreater(Host host)
|
|
{
|
|
return
|
|
TampaOrGreater(host) || // CP-2480
|
|
Helpers.productVersionCompare(Helpers.HostProductVersion(host), "6.0.1") >= 0 ||
|
|
Helpers.HostBuildNumber(host) == CUSTOM_BUILD_NUMBER;
|
|
}
|
|
|
|
/// <param name="conn">May be null, in which case true is returned.</param>
|
|
public static bool CreedenceOrGreater(IXenConnection conn)
|
|
{
|
|
return conn == null ? true : CreedenceOrGreater(Helpers.GetMaster(conn));
|
|
}
|
|
|
|
/// Creedence is ver. 1.9.0
|
|
/// <param name="host">May be null, in which case true is returned.</param>
|
|
public static bool CreedenceOrGreater(Host host)
|
|
{
|
|
if (host == null)
|
|
return true;
|
|
|
|
string platform_version = HostPlatformVersion(host);
|
|
return
|
|
platform_version != null && productVersionCompare(platform_version, "1.8.90") >= 0 ||
|
|
HostBuildNumber(host) == CUSTOM_BUILD_NUMBER;
|
|
}
|
|
|
|
/// <param name="conn">May be null, in which case true is returned.</param>
|
|
public static bool DundeeOrGreater(IXenConnection conn)
|
|
{
|
|
return conn == null ? true : DundeeOrGreater(Helpers.GetMaster(conn));
|
|
}
|
|
|
|
/// Dundee is ver. 2.0.0
|
|
/// <param name="host">May be null, in which case true is returned.</param>
|
|
public static bool DundeeOrGreater(Host host)
|
|
{
|
|
if (host == null)
|
|
return true;
|
|
|
|
string platform_version = HostPlatformVersion(host);
|
|
return
|
|
platform_version != null && productVersionCompare(platform_version, "2.0.0") >= 0 ||
|
|
HostBuildNumber(host) == CUSTOM_BUILD_NUMBER;
|
|
}
|
|
|
|
/// <param name="conn">May be null, in which case true is returned.</param>
|
|
public static bool ElyOrGreater(IXenConnection conn)
|
|
{
|
|
return conn == null ? true : ElyOrGreater(Helpers.GetMaster(conn));
|
|
}
|
|
|
|
/// Ely is ver. 2.1.1
|
|
/// <param name="host">May be null, in which case true is returned.</param>
|
|
public static bool ElyOrGreater(Host host)
|
|
{
|
|
if (host == null)
|
|
return true;
|
|
|
|
string platform_version = HostPlatformVersion(host);
|
|
return
|
|
platform_version != null && productVersionCompare(platform_version, "2.1.1") >= 0 ||
|
|
HostBuildNumber(host) == CUSTOM_BUILD_NUMBER;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Cream (Creedence SP1) has API version 2.4
|
|
/// </summary>
|
|
/// <param name="conn">May be null, in which case true is returned.</param>
|
|
/// <returns></returns>
|
|
public static bool CreamOrGreater(IXenConnection conn)
|
|
{
|
|
return conn == null || conn.Session == null || conn.Session.APIVersion >= API_Version.API_2_4;
|
|
}
|
|
|
|
public static bool DundeePlusOrGreater(IXenConnection conn)
|
|
{
|
|
return conn == null || conn.Session == null || conn.Session.APIVersion >= API_Version.API_2_6;
|
|
}
|
|
|
|
/// Clearwater is ver. 1.7.0
|
|
/// <param name="conn">May be null, in which case true is returned.</param>
|
|
public static bool IsClearwater(IXenConnection conn)
|
|
{
|
|
if(conn == null) return true;
|
|
else {
|
|
Host host = Helpers.GetMaster(conn);
|
|
return (ClearwaterOrGreater(host) && !CreedenceOrGreater(host));
|
|
}
|
|
}
|
|
|
|
/// <param name="conn">May be null, in which case true is returned.</param>
|
|
public static bool ClearwaterOrGreater(IXenConnection conn)
|
|
{
|
|
return conn == null ? true : ClearwaterOrGreater(Helpers.GetMaster(conn));
|
|
}
|
|
|
|
/// Clearwater is ver. 1.7.0
|
|
/// <param name="host">May be null, in which case true is returned.</param>
|
|
public static bool ClearwaterOrGreater(Host host)
|
|
{
|
|
if (host == null)
|
|
return true;
|
|
|
|
string platform_version = HostPlatformVersion(host);
|
|
return
|
|
platform_version != null && productVersionCompare(platform_version, "1.6.900") >= 0 ||
|
|
HostBuildNumber(host) == CUSTOM_BUILD_NUMBER;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Clearwater SP1 has API version 2.1
|
|
/// </summary>
|
|
/// <param name="conn">May be null, in which case true is returned.</param>
|
|
/// <returns></returns>
|
|
public static bool ClearwaterSp1OrGreater(IXenConnection conn)
|
|
{
|
|
return conn == null || conn.Session == null || conn.Session.APIVersion >= API_Version.API_2_1;
|
|
}
|
|
|
|
// CP-3435: Disable Check for Updates in Common Criteria Certification project
|
|
public static bool CommonCriteriaCertificationRelease
|
|
{
|
|
get { return false; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// WLB: Whether pool has wlb enabled.
|
|
/// </summary>
|
|
/// <param name="connection">May not be null.</param>
|
|
/// <returns>true when wlb is enabled, otherwise false</returns>
|
|
public static bool WlbEnabled(IXenConnection connection)
|
|
{
|
|
//Clearwater doesn't has WLB
|
|
if (IsClearwater(connection))
|
|
return false;
|
|
|
|
Pool pool = GetPoolOfOne(connection);
|
|
if (pool == null)
|
|
return false;
|
|
|
|
return pool.wlb_enabled;
|
|
}
|
|
|
|
public static bool WlbEnabledAndConfigured(IXenConnection conn)
|
|
{
|
|
return WlbEnabled(conn)&& WlbConfigured(conn);
|
|
}
|
|
|
|
public static bool WlbConfigured(IXenConnection conn)
|
|
{
|
|
//Clearwater doesn't has WLB
|
|
if (IsClearwater(conn))
|
|
return false;
|
|
|
|
Pool p = GetPoolOfOne(conn);
|
|
return (p != null && !String.IsNullOrEmpty(p.wlb_url));
|
|
}
|
|
|
|
public static bool CrossPoolMigrationRestrictedWithWlb(IXenConnection conn)
|
|
{
|
|
return WlbEnabledAndConfigured(conn) && !DundeeOrGreater(conn);
|
|
}
|
|
|
|
#region AllocationBoundsStructAndMethods
|
|
public struct AllocationBounds
|
|
{
|
|
private readonly decimal min;
|
|
private readonly decimal max;
|
|
private readonly decimal defaultValue;
|
|
private readonly string unit;
|
|
|
|
public AllocationBounds(decimal min, decimal max, decimal defaultValue)
|
|
{
|
|
this.min = min;
|
|
this.max = max;
|
|
if (defaultValue < min)
|
|
{
|
|
defaultValue = min;
|
|
}
|
|
else if (defaultValue > max)
|
|
{
|
|
defaultValue = max;
|
|
}
|
|
this.defaultValue = defaultValue;
|
|
if (defaultValue >= Util.BINARY_GIGA)
|
|
unit = Messages.VAL_GIGB;
|
|
else
|
|
unit = Messages.VAL_MEGB;
|
|
}
|
|
|
|
public AllocationBounds(decimal min, decimal max, decimal defaultValue, string unit)
|
|
: this(min, max, defaultValue)
|
|
{
|
|
this.unit = unit;
|
|
}
|
|
|
|
public decimal Min
|
|
{
|
|
get
|
|
{
|
|
return min;
|
|
}
|
|
}
|
|
|
|
public decimal Max
|
|
{
|
|
get
|
|
{
|
|
return max;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the minimum in the appropriate units
|
|
/// </summary>
|
|
public decimal MinInUnits
|
|
{
|
|
get
|
|
{
|
|
return GetValueInUnits(min);
|
|
}
|
|
}
|
|
|
|
public decimal MaxInUnits
|
|
{
|
|
get
|
|
{
|
|
return GetValueInUnits(max);
|
|
}
|
|
}
|
|
|
|
public decimal DefaultValueInUnits
|
|
{
|
|
get
|
|
{
|
|
return GetValueInUnits(defaultValue);
|
|
}
|
|
}
|
|
|
|
public string Unit
|
|
{
|
|
get
|
|
{
|
|
return unit;
|
|
}
|
|
}
|
|
|
|
private decimal GetValueInUnits(decimal val)
|
|
{
|
|
if (unit == Messages.VAL_GIGB)
|
|
return val / Util.BINARY_GIGA;
|
|
else
|
|
return val / Util.BINARY_MEGA;
|
|
}
|
|
}
|
|
|
|
public static AllocationBounds SRIncrementalAllocationBounds(long SRSize)
|
|
{
|
|
decimal min = Math.Max(SRSize / XLVHD_MIN_ALLOCATION_QUANTUM_DIVISOR , XLVHD_MIN_ALLOCATION_QUANTUM);
|
|
decimal max = Math.Max(SRSize / XLVHD_MAX_ALLOCATION_QUANTUM_DIVISOR, XLVHD_MIN_ALLOCATION_QUANTUM);
|
|
decimal defaultValue = Math.Max(SRSize / XLVHD_DEF_ALLOCATION_QUANTUM_DIVISOR, min);
|
|
|
|
return new AllocationBounds(min, max, defaultValue);
|
|
}
|
|
|
|
public static AllocationBounds VDIIncrementalAllocationBounds(long SRSize, long SRIncrAllocation)
|
|
{
|
|
decimal min = Math.Max(SRSize / XLVHD_MIN_ALLOCATION_QUANTUM_DIVISOR, XLVHD_MIN_ALLOCATION_QUANTUM);
|
|
decimal max = Math.Max(SRSize / XLVHD_MAX_ALLOCATION_QUANTUM_DIVISOR, SRIncrAllocation);
|
|
decimal defaultValue = SRIncrAllocation;
|
|
|
|
return new AllocationBounds(min, max, defaultValue);
|
|
}
|
|
|
|
public static AllocationBounds SRInitialAllocationBounds(long SRSize)
|
|
{
|
|
decimal min = 0;
|
|
decimal max = SRSize;
|
|
decimal defaultValue = 0;
|
|
|
|
return new AllocationBounds(min, max, defaultValue);
|
|
}
|
|
|
|
public static AllocationBounds VDIInitialAllocationBounds(long VDISize, long SRInitialAllocation)
|
|
{
|
|
decimal min = 0;
|
|
decimal max = VDISize;
|
|
decimal defaultValue = Math.Min(SRInitialAllocation, max);
|
|
|
|
return new AllocationBounds(min, max, defaultValue);
|
|
}
|
|
|
|
#endregion
|
|
|
|
/// <summary>
|
|
/// Determines whether two lists contain the same elements (but not necessarily in the same order).
|
|
/// Compares list elements using reference equality.
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
/// <param name="lst1">Must not be null.</param>
|
|
/// <param name="lst2">Must not be null.</param>
|
|
/// <returns></returns>
|
|
public static bool ListsContentsEqual<T>(List<T> lst1, List<T> lst2)
|
|
{
|
|
if (lst1.Count != lst2.Count)
|
|
return false;
|
|
foreach (T item1 in lst1)
|
|
if (!lst2.Contains(item1))
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
/// <summary>
|
|
///
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
/// <param name="lst1">Must not be null.</param>
|
|
/// <param name="lst2">Must not be null.</param>
|
|
/// <returns></returns>
|
|
public static List<T> ListsCommonItems<T>(List<T> lst1, List<T> lst2)
|
|
{
|
|
List<T> common = new List<T>();
|
|
foreach (T item1 in lst1)
|
|
if (lst2.Contains(item1) && !common.Contains(item1))
|
|
common.Add(item1);
|
|
foreach (T item2 in lst2)
|
|
if (lst1.Contains(item2) && !common.Contains(item2))
|
|
common.Add(item2);
|
|
return common;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Determines if two arrays have the same elements in the same order.
|
|
/// Elements may be null.
|
|
/// Uses Object.Equals() when comparing (pairs of non-null) elements.
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
/// <param name="a">Must not be null.</param>
|
|
/// <param name="b">Must not be null.</param>
|
|
/// <returns></returns>
|
|
public static bool ArrayElementsEqual<T>(T[] a, T[] b)
|
|
{
|
|
if (a.Length != b.Length)
|
|
return false;
|
|
|
|
for (int i = 0; i < a.Length; i++)
|
|
{
|
|
if (a[i] == null && b[i] == null)
|
|
continue;
|
|
if (a[i] == null)
|
|
return false;
|
|
if (!a[i].Equals(b[i]))
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
internal static bool OrderOfMagnitudeDifference(long MinSize, long MaxSize)
|
|
{
|
|
if (MinSize < Util.BINARY_KILO && MaxSize < Util.BINARY_KILO)
|
|
return false;
|
|
else if (MinSize < Util.BINARY_KILO && MaxSize > Util.BINARY_KILO)
|
|
return true;
|
|
else if (MinSize > Util.BINARY_KILO && MaxSize < Util.BINARY_KILO)
|
|
return true;
|
|
|
|
if (MinSize < Util.BINARY_MEGA && MaxSize < Util.BINARY_MEGA)
|
|
return false;
|
|
else if (MinSize < Util.BINARY_MEGA && MaxSize > Util.BINARY_MEGA)
|
|
return true;
|
|
else if (MinSize > Util.BINARY_MEGA && MaxSize < Util.BINARY_MEGA)
|
|
return true;
|
|
|
|
if (MinSize < Util.BINARY_GIGA && MaxSize < Util.BINARY_GIGA)
|
|
return false;
|
|
else if (MinSize < Util.BINARY_GIGA && MaxSize > Util.BINARY_GIGA)
|
|
return true;
|
|
else if (MinSize > Util.BINARY_GIGA && MaxSize < Util.BINARY_GIGA)
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
public static string StringFromMaxMinSize(long min, long max)
|
|
{
|
|
if (min == -1 && max == -1)
|
|
return Messages.SIZE_NEGLIGIBLE;
|
|
else if (min == -1)
|
|
return Util.LThanSize(max);
|
|
else if (max == -1)
|
|
return Util.GThanSize(min);
|
|
else if (min == max)
|
|
return Util.DiskSizeString(max);
|
|
else if (Helpers.OrderOfMagnitudeDifference(min, max))
|
|
return string.Format("{0} - {1}", Util.DiskSizeString(min), Util.DiskSizeString(max));
|
|
else
|
|
return string.Format("{0} - {1}", Util.DiskSizeStringWithoutUnits(min), Util.DiskSizeString(max));
|
|
}
|
|
|
|
public static string StringFromMaxMinTime(long min, long max)
|
|
{
|
|
if (min == -1 && max == -1)
|
|
return Messages.TIME_NEGLIGIBLE;
|
|
else if (min == -1)
|
|
return Util.LThanTime(max);
|
|
else if (max == -1)
|
|
return Util.GThanTime(min);
|
|
else if (min == max)
|
|
return Util.TimeString(max);
|
|
else
|
|
return Util.TimeRangeString(min, max);
|
|
}
|
|
|
|
public static string StringFromMaxMinTimeList(List<long> minList, List<long> maxList)
|
|
{
|
|
bool lessFlag = false;
|
|
bool moreFlag = false;
|
|
bool negligFlag = false;
|
|
|
|
long minSum = 0;
|
|
long maxSum = 0;
|
|
|
|
for (int i = 0; i < minList.Count; i++)
|
|
{
|
|
if (minList[i] < 0 && maxList[i] < 0)
|
|
{
|
|
negligFlag = true;
|
|
}
|
|
else if (minList[i] < 0)
|
|
{
|
|
maxSum += maxList[i];
|
|
lessFlag = true;
|
|
}
|
|
else if (maxList[i] < 0)
|
|
{
|
|
minSum += minList[i];
|
|
moreFlag = true;
|
|
}
|
|
else
|
|
{
|
|
minSum += minList[i];
|
|
maxSum += maxList[i];
|
|
}
|
|
}
|
|
|
|
if (moreFlag)
|
|
return Util.GThanTime(minSum);
|
|
if (lessFlag)
|
|
return Util.LThanTime(maxSum);
|
|
if (negligFlag && maxSum <= 0)
|
|
return Util.TimeString(maxSum);
|
|
return StringFromMaxMinTime(minSum, maxSum);
|
|
|
|
}
|
|
|
|
public static string StringFromMaxMinSizeList(List<long> minList, List<long> maxList)
|
|
{
|
|
bool lessFlag = false;
|
|
bool moreFlag = false;
|
|
bool negligFlag = false;
|
|
|
|
long minSum = 0;
|
|
long maxSum = 0;
|
|
|
|
for (int i = 0; i < minList.Count; i++)
|
|
{
|
|
if (minList[i] < 0 && maxList[i] < 0)
|
|
{
|
|
negligFlag = true;
|
|
}
|
|
else if (minList[i] < 0)
|
|
{
|
|
maxSum += maxList[i];
|
|
lessFlag = true;
|
|
}
|
|
else if (maxList[i] < 0)
|
|
{
|
|
minSum += minList[i];
|
|
moreFlag = true;
|
|
}
|
|
else
|
|
{
|
|
minSum += minList[i];
|
|
maxSum += maxList[i];
|
|
}
|
|
}
|
|
|
|
if (moreFlag)
|
|
return Util.GThanSize(minSum);
|
|
if (lessFlag)
|
|
return Util.LThanSize(maxSum);
|
|
if (negligFlag && maxSum <= 0)
|
|
return Util.DiskSizeString(maxSum);
|
|
return StringFromMaxMinSize(minSum, maxSum);
|
|
}
|
|
|
|
|
|
public static string GetCPUProperties(Host_cpu cpu)
|
|
{
|
|
return string.Format("{0}\n{1}\n{2}",
|
|
string.Format(Messages.GENERAL_CPU_VENDOR, cpu.vendor),
|
|
string.Format(Messages.GENERAL_CPU_MODEL, cpu.modelname),
|
|
string.Format(Messages.GENERAL_CPU_SPEED, cpu.speed));
|
|
}
|
|
|
|
public static string GetAllocationProperties(string initial_allocation, string quantum_allocation)
|
|
{
|
|
return string.Format(Messages.SR_DISK_SPACE_ALLOCATION,
|
|
Util.MemorySizeStringSuitableUnits(Convert.ToDouble(initial_allocation), true, Messages.VAL_MB),
|
|
Util.MemorySizeStringSuitableUnits(Convert.ToDouble(quantum_allocation), true, Messages.VAL_MB));
|
|
}
|
|
|
|
public static string GetHostRestrictions(Host host)
|
|
{
|
|
string output = "";
|
|
|
|
List<string> restrictions = new List<string>();
|
|
|
|
// Build license details info box
|
|
foreach (String key in host.license_params.Keys)
|
|
{
|
|
if (host.license_params[key] == "true")
|
|
{
|
|
restrictions.Add(key);
|
|
}
|
|
}
|
|
|
|
bool first = true;
|
|
restrictions.Sort();
|
|
foreach (String restriction in restrictions)
|
|
{
|
|
string restrictionText = Messages.ResourceManager.GetString(restriction);
|
|
if (restrictionText == null)
|
|
continue;
|
|
|
|
if (first)
|
|
{
|
|
output += restrictionText;
|
|
first = false;
|
|
continue;
|
|
}
|
|
|
|
output += "\n" + restrictionText;
|
|
}
|
|
return output;
|
|
}
|
|
|
|
public static string BoolToString(bool b)
|
|
{
|
|
return b ? Messages.YES : Messages.NO;
|
|
}
|
|
|
|
private static readonly Regex IqnRegex = new Regex(@"^iqn\.\d{4}-\d{2}\.([a-zA-Z0-9][-_a-zA-Z0-9]*(\.[a-zA-Z0-9][-_a-zA-Z0-9]*)*)(:.+)?$", RegexOptions.ECMAScript);
|
|
|
|
public static bool ValidateIscsiIQN(string iqn)
|
|
{
|
|
return IqnRegex.IsMatch(iqn);
|
|
}
|
|
|
|
public static bool IsOlderThanMaster(Host host)
|
|
{
|
|
Host master = Helpers.GetMaster(host.Connection);
|
|
if (master == null || master.opaque_ref == host.opaque_ref)
|
|
return false;
|
|
else if (Helpers.productVersionCompare(Helpers.HostProductVersion(host), Helpers.HostProductVersion(master)) >= 0)
|
|
return false;
|
|
else
|
|
return true;
|
|
}
|
|
|
|
|
|
private static readonly Regex MacRegex = new Regex(@"^([0-9a-fA-F]{2}:){5}[0-9a-fA-F]{2}$");
|
|
|
|
public static bool IsValidMAC(string macString)
|
|
{
|
|
return MacRegex.IsMatch(macString);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Recursively sums the total size of all files in the directory tree rooted at the given dir.
|
|
/// </summary>
|
|
public static long GetDirSize(DirectoryInfo dir)
|
|
{
|
|
long size = 0;
|
|
FileInfo[] files = dir.GetFiles();
|
|
foreach (FileInfo file in files)
|
|
{
|
|
size += file.Length;
|
|
}
|
|
|
|
DirectoryInfo[] subdirs = dir.GetDirectories();
|
|
foreach (DirectoryInfo subdir in subdirs)
|
|
{
|
|
size += GetDirSize(subdir);
|
|
}
|
|
return size;
|
|
}
|
|
|
|
public static string ToWindowsLineEndings(string input)
|
|
{
|
|
return Regex.Replace(input, "\r?\n", "\r\n");
|
|
}
|
|
|
|
public static bool PoolHasEnabledHosts(Pool pool)
|
|
{
|
|
foreach (Host host in pool.Connection.Cache.Hosts)
|
|
{
|
|
if (host.enabled)
|
|
{
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
|
|
public static string MakeUniqueName(string stub, List<string> compareAgainst)
|
|
{
|
|
string pre = stub;
|
|
int i = 1;
|
|
while (compareAgainst.Contains(stub))
|
|
{
|
|
stub = string.Format(Messages.NEWVM_DEFAULTNAME, pre, i);
|
|
i++;
|
|
}
|
|
return stub;
|
|
}
|
|
|
|
public static string MakeUniqueNameFromPattern(string pattern, List<string> compareAgainst, int startAt)
|
|
{
|
|
int i = startAt;
|
|
string val;
|
|
do
|
|
{
|
|
val = string.Format(pattern, i++);
|
|
} while (compareAgainst.Contains(val));
|
|
|
|
return val;
|
|
}
|
|
|
|
public static string MakeHiddenName(string name)
|
|
{
|
|
return string.Format("{0}{1}", GuiTempObjectPrefix, name);
|
|
}
|
|
|
|
public static string GetFriendlyLicenseName(Host host)
|
|
{
|
|
if (string.IsNullOrEmpty(host.edition))
|
|
return Messages.UNKNOWN;
|
|
|
|
string name = PropertyManager.GetFriendlyName("Label-host.edition-" + host.edition);
|
|
return name ?? Messages.UNKNOWN;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Used for determining which features are available on the current license.
|
|
/// Note that all the features are per-pool: e.g., even if iXenObject is a Host,
|
|
/// we return whether *any* the hosts in that pool are forbidden that feature.
|
|
/// </summary>
|
|
public static bool FeatureForbidden(IXenObject iXenObject, Predicate<Host> restrictionTest)
|
|
{
|
|
IXenConnection connection = (iXenObject == null ? null : iXenObject.Connection);
|
|
return FeatureForbidden(connection, restrictionTest);
|
|
}
|
|
|
|
public static bool FeatureForbidden(IXenConnection xenConnection, Predicate<Host> restrictionTest)
|
|
{
|
|
if (xenConnection == null)
|
|
return false;
|
|
|
|
foreach (Host host in xenConnection.Cache.Hosts)
|
|
{
|
|
if (restrictionTest(host))
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Shuffles a list in-place.
|
|
/// </summary>
|
|
/// <typeparam name="T"></typeparam>
|
|
/// <param name="listToShuffle"></param>
|
|
public static void ShuffleList<T>(List<T> listToShuffle)
|
|
{
|
|
Random r = new Random();
|
|
|
|
for (int k = listToShuffle.Count - 1; k > 1; --k)
|
|
{
|
|
int randIndx = r.Next(k);
|
|
T temp = listToShuffle[k];
|
|
listToShuffle[k] = listToShuffle[randIndx];
|
|
listToShuffle[randIndx] = temp;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Parse string represented double to a double with en-US number format
|
|
/// </summary>
|
|
/// <param name="toParse">String represented double</param>
|
|
/// <param name="defaultValue">Default value to use if the string can't be parsed</param>
|
|
/// <returns>The parsed double.</returns>
|
|
public static double ParseStringToDouble(string toParse, double defaultValue)
|
|
{
|
|
double doubleValue;
|
|
if (!double.TryParse(toParse, NumberStyles.Any, _nfi, out doubleValue))
|
|
{
|
|
doubleValue = defaultValue;
|
|
}
|
|
return doubleValue;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Return the UUID of the given XenObject, or the empty string if that can't be found.
|
|
/// </summary>
|
|
public static string GetUuid(IXenObject iXenObject)
|
|
{
|
|
if (iXenObject == null)
|
|
return "";
|
|
Type t = iXenObject.GetType();
|
|
PropertyInfo p = t.GetProperty("uuid", BindingFlags.Public | BindingFlags.Instance);
|
|
if (p == null)
|
|
return "";
|
|
return (string)p.GetValue(iXenObject, null);
|
|
}
|
|
|
|
#region Reflexive other_config and gui_config functions
|
|
|
|
public static Dictionary<String, String> GetOtherConfig(IXenObject o)
|
|
{
|
|
return o.Get("other_config") as Dictionary<String, String>;
|
|
}
|
|
|
|
public static void SetOtherConfig(Session session, IXenObject o, String key, String value)
|
|
{
|
|
//Program.AssertOffEventThread();
|
|
|
|
o.Do("remove_from_other_config", session, o.opaque_ref, key);
|
|
o.Do("add_to_other_config", session, o.opaque_ref, key, value);
|
|
}
|
|
|
|
public static void RemoveFromOtherConfig(Session session, IXenObject o, string key)
|
|
{
|
|
//Program.AssertOffEventThread();
|
|
|
|
o.Do("remove_from_other_config", session, o.opaque_ref, key);
|
|
}
|
|
|
|
public static Dictionary<String, String> GetGuiConfig(IXenObject o)
|
|
{
|
|
return o.Get("gui_config") as Dictionary<String, String>;
|
|
}
|
|
|
|
public static void SetGuiConfig(Session session, IXenObject o, String key, String value)
|
|
{
|
|
//Program.AssertOffEventThread();
|
|
|
|
o.Do("remove_from_gui_config", session, o.opaque_ref, key);
|
|
o.Do("add_to_gui_config", session, o.opaque_ref, key, value);
|
|
}
|
|
|
|
public static void RemoveFromGuiConfig(Session session, IXenObject o, string key)
|
|
{
|
|
//Program.AssertOffEventThread();
|
|
|
|
o.Do("remove_from_gui_config", session, o.opaque_ref, key);
|
|
}
|
|
|
|
#endregion
|
|
|
|
public static Regex CpuRegex = new Regex("^cpu([0-9]+)$");
|
|
public static Regex CpuStateRegex = new Regex("^cpu([0-9]+)-(C|P)([0-9]+)$");
|
|
static Regex VifRegex = new Regex("^vif_([0-9]+)_(tx|rx)((_errors)?)$");
|
|
static Regex PifEthRegex = new Regex("^pif_eth([0-9]+)_(tx|rx)((_errors)?)$");
|
|
static Regex PifVlanRegex = new Regex("^pif_eth([0-9]+).([0-9]+)_(tx|rx)((_errors)?)$");
|
|
static Regex PifBrRegex = new Regex("^pif_xenbr([0-9]+)_(tx|rx)((_errors)?)$");
|
|
static Regex PifXapiRegex = new Regex("^pif_xapi([0-9]+)_(tx|rx)((_errors)?)$");
|
|
static Regex PifTapRegex = new Regex("^pif_tap([0-9]+)_(tx|rx)((_errors)?)$");
|
|
static Regex PifLoRegex = new Regex("^pif_lo_(tx|rx)((_errors)?)$");
|
|
static Regex PifBondRegex = new Regex("^pif_(bond[0-9]+)_(tx|rx)((_errors)?)$");
|
|
static Regex DiskRegex = new Regex("^vbd_((xvd|hd)[a-z]+)_(read|write)((_latency)?)$");
|
|
static Regex DiskIopsRegex = new Regex("^vbd_((xvd|hd)[a-z]+)_iops_(read|write|total)$");
|
|
static Regex DiskThroughputRegex = new Regex("^vbd_((xvd|hd)[a-z]+)_io_throughput_(read|write|total)$");
|
|
static Regex DiskOtherRegex = new Regex("^vbd_((xvd|hd)[a-z]+)_(avgqu_sz|inflight|iowait)$");
|
|
static Regex NetworkLatencyRegex = new Regex("^network/latency$");
|
|
static Regex XapiLatencyRegex = new Regex("^xapi_healthcheck/latency$");
|
|
static Regex StatefileLatencyRegex = new Regex("^statefile/[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}/latency$");
|
|
static Regex LoadAvgRegex = new Regex("loadavg");
|
|
static Regex SrRegex = new Regex("^sr_[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}_cache_(size|hits|misses)");
|
|
static Regex SrIORegex = new Regex("^(io_throughput|iops)_(read|write|total)_([a-f0-9]{8})$");
|
|
static Regex SrOtherRegex = new Regex("^(latency|avgqu_sz|inflight|iowait)_([a-f0-9]{8})$");
|
|
static Regex SrReadWriteRegex = new Regex("^((read|write)(_latency)?)_([a-f0-9]{8})$");
|
|
static Regex GpuRegex = new Regex(@"^gpu_((memory_(free|used))|power_usage|temperature|(utilisation_(compute|memory_io)))_(([a-fA-F0-9]{4}\/)?[a-fA-F0-9]{2}\/[0-1][a-fA-F0-9].[0-7])$");
|
|
|
|
public static string GetFriendlyDataSourceName(string name, IXenObject iXenObject)
|
|
{
|
|
if (iXenObject == null)
|
|
return name;
|
|
string s = GetFriendlyDataSourceName_(name, iXenObject);
|
|
return string.IsNullOrEmpty(s) ? name : s;
|
|
}
|
|
|
|
private static string GetFriendlyDataSourceName_(string name, IXenObject iXenObject)
|
|
{
|
|
Match m;
|
|
|
|
m = CpuRegex.Match(name);
|
|
if (m.Success)
|
|
return FormatFriendly("Label-performance.cpu", m.Groups[1].Value);
|
|
|
|
m = VifRegex.Match(name);
|
|
if (m.Success)
|
|
{
|
|
string device = m.Groups[1].Value;
|
|
XenAPI.Network network = FindNetworkOfVIF(iXenObject, device);
|
|
return network == null
|
|
? null //don't try to retrieve it in the FriendlyNames.
|
|
: FormatFriendly(string.Format("Label-performance.vif_{0}{1}",
|
|
m.Groups[2].Value, m.Groups[3].Value), network.Name);
|
|
}
|
|
|
|
m = PifEthRegex.Match(name);
|
|
if (m.Success)
|
|
return FormatFriendly(string.Format("Label-performance.nic_{0}{1}", m.Groups[2].Value, m.Groups[3].Value), m.Groups[1].Value);
|
|
|
|
m = PifVlanRegex.Match(name);
|
|
if (m.Success)
|
|
{
|
|
string device = string.Format("eth{0}", m.Groups[1].Value);
|
|
XenAPI.Network network = FindVlan(iXenObject, device, m.Groups[2].Value);
|
|
return network == null
|
|
? null //don't try to retrieve it in the FriendlyNames.
|
|
: FormatFriendly(string.Format("Label-performance.vlan_{0}{1}",
|
|
m.Groups[3].Value, m.Groups[4].Value), network.Name);
|
|
}
|
|
|
|
m = PifBrRegex.Match(name);
|
|
if (m.Success)
|
|
{
|
|
string device = string.Format("eth{0}", m.Groups[1].Value);
|
|
XenAPI.Network network = FindNetworkOfPIF(iXenObject, device);
|
|
return network == null
|
|
? null //don't try to retrieve it in the FriendlyNames.
|
|
: FormatFriendly(string.Format("Label-performance.xenbr_{0}{1}", m.Groups[2].Value, m.Groups[3].Value), network.Name);
|
|
}
|
|
|
|
m = PifXapiRegex.Match(name);
|
|
if (m.Success)
|
|
return FormatFriendly(string.Format("Label-performance.xapi_{0}{1}", m.Groups[2].Value, m.Groups[3].Value), m.Groups[1].Value);
|
|
|
|
m = PifBondRegex.Match(name);
|
|
if (m.Success)
|
|
{
|
|
PIF pif = FindPIF(iXenObject, m.Groups[1].Value, false);
|
|
return pif == null
|
|
? null //pif doesn't exist anymore so don't try to retrieve it in the FriendlyNames.
|
|
: FormatFriendly(string.Format("Label-performance.bond_{0}{1}", m.Groups[2].Value, m.Groups[3].Value), pif.Name);
|
|
}
|
|
|
|
m = PifLoRegex.Match(name);
|
|
if (m.Success)
|
|
return FormatFriendly(string.Format("Label-performance.lo_{0}{1}", m.Groups[1].Value, m.Groups[2].Value));
|
|
|
|
m = PifTapRegex.Match(name);
|
|
if (m.Success)
|
|
return FormatFriendly(string.Format("Label-performance.tap_{0}{1}", m.Groups[2].Value, m.Groups[3].Value), m.Groups[1].Value);
|
|
|
|
m = DiskRegex.Match(name);
|
|
if (m.Success)
|
|
{
|
|
VBD vbd = FindVBD(iXenObject, m.Groups[1].Value);
|
|
return vbd == null
|
|
? null
|
|
: FormatFriendly(string.Format("Label-performance.vbd_{0}{1}", m.Groups[3].Value, m.Groups[4].Value), vbd.userdevice);
|
|
}
|
|
|
|
m = DiskIopsRegex.Match(name);
|
|
if (m.Success)
|
|
{
|
|
VBD vbd = FindVBD(iXenObject, m.Groups[1].Value);
|
|
return vbd == null
|
|
? null
|
|
: FormatFriendly(string.Format("Label-performance.vbd_iops_{0}", m.Groups[3].Value),
|
|
vbd.userdevice);
|
|
}
|
|
|
|
m = DiskThroughputRegex.Match(name);
|
|
if (m.Success)
|
|
{
|
|
VBD vbd = FindVBD(iXenObject, m.Groups[1].Value);
|
|
return vbd == null
|
|
? null
|
|
: FormatFriendly(string.Format("Label-performance.vbd_io_throughput_{0}", m.Groups[3].Value),
|
|
vbd.userdevice);
|
|
}
|
|
|
|
m = DiskOtherRegex.Match(name);
|
|
if (m.Success)
|
|
{
|
|
VBD vbd = FindVBD(iXenObject, m.Groups[1].Value);
|
|
return vbd == null
|
|
? null
|
|
: FormatFriendly(string.Format("Label-performance.vbd_{0}", m.Groups[3].Value),
|
|
vbd.userdevice);
|
|
}
|
|
|
|
m = SrRegex.Match(name);
|
|
if (m.Success)
|
|
return FormatFriendly(string.Format("Label-performance.sr_cache_{0}", m.Groups[1].Value));
|
|
|
|
m = CpuStateRegex.Match(name);
|
|
if (m.Success)
|
|
return FormatFriendly("Label-performance.cpu-state", m.Groups[1].Value, m.Groups[2].Value, m.Groups[3].Value);
|
|
|
|
m = SrIORegex.Match(name);
|
|
if (m.Success)
|
|
{
|
|
SR sr = FindSr(iXenObject, m.Groups[3].Value);
|
|
return sr == null
|
|
? null
|
|
: FormatFriendly(string.Format("Label-performance.sr_{0}_{1}",
|
|
m.Groups[1].Value, m.Groups[2].Value),
|
|
sr.Name.Ellipsise(30));
|
|
}
|
|
|
|
m = SrOtherRegex.Match(name);
|
|
if (m.Success)
|
|
{
|
|
SR sr = FindSr(iXenObject, m.Groups[2].Value);
|
|
return sr == null
|
|
? null
|
|
: FormatFriendly(string.Format("Label-performance.sr_{0}", m.Groups[1].Value),
|
|
sr.Name.Ellipsise(30));
|
|
}
|
|
|
|
m = SrReadWriteRegex.Match(name);
|
|
if (m.Success)
|
|
{
|
|
SR sr = FindSr(iXenObject, m.Groups[4].Value);
|
|
return sr == null
|
|
? null
|
|
: FormatFriendly(string.Format("Label-performance.sr_rw_{0}", m.Groups[1].Value),
|
|
sr.Name.Ellipsise(30));
|
|
}
|
|
|
|
m = GpuRegex.Match(name);
|
|
if (m.Success)
|
|
{
|
|
string pciId = m.Groups[6].Value.Replace(@"/", ":");
|
|
PGPU gpu = FindGpu(iXenObject, pciId);
|
|
return gpu == null
|
|
? null
|
|
: FormatFriendly(string.Format("Label-performance.gpu_{0}", m.Groups[1].Value),
|
|
gpu.Name, pciId);
|
|
}
|
|
|
|
if (NetworkLatencyRegex.IsMatch(name))
|
|
return PropertyManager.GetFriendlyName("Label-performance.network_latency");
|
|
|
|
if (XapiLatencyRegex.IsMatch(name))
|
|
return PropertyManager.GetFriendlyName("Label-performance.xapi_latency");
|
|
|
|
if (StatefileLatencyRegex.IsMatch(name))
|
|
return PropertyManager.GetFriendlyName("Label-performance.statefile_latency");
|
|
|
|
if (LoadAvgRegex.IsMatch(name))
|
|
return PropertyManager.GetFriendlyName("Label-performance.loadavg");
|
|
|
|
return PropertyManager.GetFriendlyName(string.Format("Label-performance.{0}", name));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Lookup key using PropertyManager.GetFriendlyName, and then apply that as a format pattern to the given args.
|
|
/// </summary>
|
|
private static string FormatFriendly(string key, params string[] args)
|
|
{
|
|
return string.Format(PropertyManager.GetFriendlyName(key), args);
|
|
}
|
|
|
|
private static PGPU FindGpu(IXenObject iXenObject, string pciId)
|
|
{
|
|
foreach (PCI pci in iXenObject.Connection.Cache.PCIs)
|
|
{
|
|
if (pci.pci_id != pciId)
|
|
continue;
|
|
|
|
foreach (PGPU gpu in iXenObject.Connection.Cache.PGPUs)
|
|
{
|
|
if (gpu.PCI.opaque_ref == pci.opaque_ref)
|
|
return gpu;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static XenAPI.Network FindNetworkOfVIF(IXenObject iXenObject, string device)
|
|
{
|
|
foreach (VIF vif in iXenObject.Connection.Cache.VIFs)
|
|
{
|
|
if (vif.device == device && (iXenObject is Host && ((Host)iXenObject).resident_VMs.Contains(vif.VM) || iXenObject is VM && vif.VM.opaque_ref == iXenObject.opaque_ref))
|
|
{
|
|
XenAPI.Network network = iXenObject.Connection.Resolve(vif.network);
|
|
if (network != null)
|
|
return network;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static XenAPI.Network FindNetworkOfPIF(IXenObject iXenObject, string device)
|
|
{
|
|
PIF pif = FindPIF(iXenObject, device, true);
|
|
if (pif != null)
|
|
{
|
|
XenAPI.Network network = iXenObject.Connection.Resolve(pif.network);
|
|
if (network != null)
|
|
return network;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static XenAPI.Network FindVlan(IXenObject iXenObject, string device, string tag)
|
|
{
|
|
foreach (PIF pif in iXenObject.Connection.Cache.PIFs)
|
|
{
|
|
if (pif.device == device && (iXenObject is Host && pif.host.opaque_ref == iXenObject.opaque_ref || iXenObject is VM && pif.host.opaque_ref == ((VM)iXenObject).resident_on.opaque_ref) && pif.VLAN == long.Parse(tag))
|
|
{
|
|
return iXenObject.Connection.Resolve(pif.network);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static PIF FindPIF(IXenObject iXenObject, string device, bool physical)
|
|
{
|
|
foreach (PIF pif in iXenObject.Connection.Cache.PIFs)
|
|
{
|
|
if ((!physical || pif.IsPhysical) && pif.device == device && (iXenObject is Host && pif.host.opaque_ref == iXenObject.opaque_ref || iXenObject is VM && pif.host.opaque_ref == ((VM)iXenObject).resident_on.opaque_ref))
|
|
return pif;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static VBD FindVBD(IXenObject iXenObject, string device)
|
|
{
|
|
if (iXenObject is VM)
|
|
{
|
|
VM vm = (VM)iXenObject;
|
|
foreach (VBD vbd in vm.Connection.ResolveAll(vm.VBDs))
|
|
{
|
|
if (vbd.device == device)
|
|
return vbd;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static SR FindSr(IXenObject iXenObject, string srUuid)
|
|
{
|
|
foreach (var sr in iXenObject.Connection.Cache.SRs)
|
|
{
|
|
if (sr.uuid.StartsWith(srUuid))
|
|
return sr;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the first line of the given string, or the empty string if null was passed in. Will take the first occurence of \r or \n
|
|
/// as the end of a line.
|
|
/// </summary>
|
|
/// <param name="s"></param>
|
|
/// <returns></returns>
|
|
public static string FirstLine(string s)
|
|
{
|
|
if (s == null)
|
|
{
|
|
return "";
|
|
}
|
|
else
|
|
{
|
|
s = s.Split(new char[] { '\n' })[0];
|
|
return s.Split(new char[] { '\r' })[0];
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns empty string if mainline
|
|
/// </summary>
|
|
public static string OEMName(Host host)
|
|
{
|
|
if (host.software_version == null)
|
|
return string.Empty;
|
|
|
|
if (!host.software_version.ContainsKey("oem_manufacturer"))
|
|
return "";
|
|
|
|
return host.software_version["oem_manufacturer"].ToLowerInvariant();
|
|
}
|
|
|
|
public static string HostProductVersionWithOEM(Host host)
|
|
{
|
|
string oem = OEMName(host);
|
|
if (string.IsNullOrEmpty(oem))
|
|
return HostProductVersion(host);
|
|
else
|
|
return string.Format("{0}.{1}", HostProductVersion(host), OEMName(host));
|
|
}
|
|
|
|
|
|
public static double StringToDouble(string str)
|
|
{
|
|
if (str == "NaN")
|
|
return Double.NaN;
|
|
else if (str == "Infinity")
|
|
return Double.PositiveInfinity;
|
|
else if (str == "-Infinity")
|
|
return Double.NegativeInfinity;
|
|
else
|
|
return Convert.ToDouble(str, CultureInfo.InvariantCulture);
|
|
}
|
|
|
|
public static bool HAEnabled(IXenConnection connection)
|
|
{
|
|
Pool pool = Helpers.GetPoolOfOne(connection);
|
|
if (pool == null)
|
|
return false;
|
|
|
|
return pool.ha_enabled;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns "type 'name'" for the specified object, e.g. "pool 'foo'".
|
|
/// </summary>
|
|
/// <param name="XenObject"></param>
|
|
/// <returns></returns>
|
|
public static string GetNameAndObject(IXenObject XenObject)
|
|
{
|
|
if (XenObject is Pool)
|
|
return string.Format(Messages.POOL_X, GetName(XenObject));
|
|
|
|
if (XenObject is Host)
|
|
return string.Format(Messages.SERVER_X, GetName(XenObject));
|
|
|
|
if (XenObject is VM)
|
|
{
|
|
VM vm = (VM)XenObject;
|
|
if (vm.IsControlDomainZero)
|
|
return string.Format(Messages.SERVER_X, GetName(XenObject.Connection.Resolve(vm.resident_on)));
|
|
else
|
|
return string.Format(Messages.VM_X, GetName(XenObject));
|
|
}
|
|
|
|
if (XenObject is SR)
|
|
return string.Format(Messages.STORAGE_REPOSITORY_X, GetName(XenObject));
|
|
|
|
return Messages.UNKNOWN_OBJECT;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the i18n'd name for a HA restart priority according to FriendlyNames.
|
|
/// </summary>
|
|
/// <param name="priority"></param>
|
|
/// <returns></returns>
|
|
public static string RestartPriorityI18n(VM.HA_Restart_Priority? priority)
|
|
{
|
|
if (priority == null)
|
|
{
|
|
return "";
|
|
}
|
|
else
|
|
{
|
|
return XenAdmin.Core.PropertyManager.GetFriendlyName("Label-VM.ha_restart_priority." + priority.ToString()) ?? priority.ToString();
|
|
}
|
|
}
|
|
|
|
public static string RestartPriorityDescription(VM.HA_Restart_Priority? priority)
|
|
{
|
|
if (priority == null)
|
|
{
|
|
return "";
|
|
}
|
|
else
|
|
{
|
|
return XenAdmin.Core.PropertyManager.GetFriendlyName("Description-VM.ha_restart_priority." + priority.ToString()) ?? priority.ToString();
|
|
}
|
|
}
|
|
|
|
|
|
/// <summary>
|
|
/// Builds up a dictionary of the current restart priorities for all the VMs in the given IXenConnection.
|
|
/// </summary>
|
|
/// <param name="connection">Must not be null.</param>
|
|
/// <returns></returns>
|
|
public static Dictionary<VM, VM.HA_Restart_Priority> GetVmHaRestartPriorities(IXenConnection connection,bool showHiddenVMs)
|
|
{
|
|
Dictionary<VM, VM.HA_Restart_Priority> result = new Dictionary<VM, VM.HA_Restart_Priority>();
|
|
foreach (VM vm in connection.Cache.VMs)
|
|
{
|
|
if (vm.HaCanProtect(showHiddenVMs))
|
|
{
|
|
result[vm] = vm.HARestartPriority;
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Converts Dictionary<XenObject<VM>, VM.HA_Restart_Priority> -> Dictionary<XenRef<VM>, string>.
|
|
/// The former is useful in the GUI, the latter is suitable for sending into compute_hypothetical_max.
|
|
/// </summary>
|
|
/// <param name="settings">Must not be null.</param>
|
|
/// <returns></returns>
|
|
public static Dictionary<XenRef<VM>, string> GetVmHaRestartPrioritiesForApi(Dictionary<VM, VM.HA_Restart_Priority> settings)
|
|
{
|
|
Dictionary<XenRef<VM>, string> result = new Dictionary<XenRef<VM>, string>();
|
|
foreach (VM vm in settings.Keys)
|
|
{
|
|
if (settings[vm] == VM.HA_Restart_Priority.BestEffort || settings[vm] == VM.HA_Restart_Priority.DoNotRestart)
|
|
{
|
|
// The server doesn't want to know about best-effort/do not restart VMs.
|
|
// (They don't influence the plan, and sending in the dictionary gives an error).
|
|
continue;
|
|
}
|
|
result[new XenRef<VM>(vm.opaque_ref)] = VM.PriorityToString(settings[vm]);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Builds up a dictionary of the current startup options for all the VMs in the given IXenConnection.
|
|
/// </summary>
|
|
/// <param name="connection">Must not be null.</param>
|
|
/// <returns></returns>
|
|
public static Dictionary<VM, VMStartupOptions> GetVmStartupOptions(IXenConnection connection, bool showHiddenVMs)
|
|
{
|
|
Dictionary<VM, VMStartupOptions> result = new Dictionary<VM, VMStartupOptions>();
|
|
foreach (VM vm in connection.Cache.VMs)
|
|
{
|
|
if (vm.HaCanProtect(showHiddenVMs))
|
|
{
|
|
result[vm] = new VMStartupOptions(vm.order, vm.start_delay, vm.HARestartPriority);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieves a IXenObject from a message. May return null if type not recognised.
|
|
/// </summary>
|
|
/// <param name="message"></param>
|
|
/// <returns></returns>
|
|
public static IXenObject XenObjectFromMessage(XenAPI.Message message)
|
|
{
|
|
switch (message.cls)
|
|
{
|
|
case cls.Pool:
|
|
Pool pool = message.Connection.Cache.Find_By_Uuid<Pool>(message.obj_uuid);
|
|
if (pool != null)
|
|
return pool;
|
|
break;
|
|
case cls.Host:
|
|
Host host = message.Connection.Cache.Find_By_Uuid<Host>(message.obj_uuid);
|
|
if (host != null)
|
|
return host;
|
|
break;
|
|
case cls.VM:
|
|
VM vm = message.Connection.Cache.Find_By_Uuid<VM>(message.obj_uuid);
|
|
if (vm != null)
|
|
return vm;
|
|
break;
|
|
case cls.SR:
|
|
SR sr = message.Connection.Cache.Find_By_Uuid<SR>(message.obj_uuid);
|
|
if (sr != null)
|
|
return sr;
|
|
break;
|
|
case cls.VMPP:
|
|
VMPP vmpp = message.Connection.Cache.Find_By_Uuid<VMPP>(message.obj_uuid);
|
|
if (vmpp != null)
|
|
return vmpp;
|
|
break;
|
|
case cls.PVS_proxy:
|
|
PVS_proxy proxy = message.Connection.Cache.Find_By_Uuid<PVS_proxy>(message.obj_uuid);
|
|
if (proxy != null)
|
|
return proxy;
|
|
break;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
|
|
public static int Max(params int[] arr)
|
|
{
|
|
int result = int.MinValue;
|
|
foreach (int i in arr)
|
|
{
|
|
if (i > result)
|
|
result = i;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Load an xml stream and ignore comments and whitespace
|
|
/// </summary>
|
|
/// <param name="xmlStream"></param>
|
|
/// <returns></returns>
|
|
public static XmlDocument LoadXmlDocument(Stream xmlStream)
|
|
{
|
|
XmlDocument doc = new XmlDocument();
|
|
XmlReaderSettings settings = new XmlReaderSettings();
|
|
|
|
settings.IgnoreComments = true;
|
|
settings.IgnoreWhitespace = true;
|
|
settings.IgnoreProcessingInstructions = true;
|
|
|
|
doc.Load(XmlReader.Create(xmlStream, settings));
|
|
|
|
return doc;
|
|
}
|
|
|
|
public static Regex HostnameOrIpRegex = new Regex(@"[\w.]+");
|
|
|
|
public static string HostnameFromLocation(string p)
|
|
{
|
|
foreach (Match m in HostnameOrIpRegex.Matches(p))
|
|
{
|
|
return m.Value; // we only want the hostname or ip which should be the first match
|
|
}
|
|
return "";
|
|
}
|
|
|
|
public static string GetStringXmlAttribute(XmlNode Node, string AttributeName)
|
|
{
|
|
if (Node.Attributes[AttributeName] == null)
|
|
return null;
|
|
return Node.Attributes[AttributeName].Value;
|
|
}
|
|
|
|
public static string GetStringXmlAttribute(XmlNode Node, string AttributeName, string Default)
|
|
{
|
|
if (Node.Attributes[AttributeName] == null)
|
|
return Default;
|
|
return Node.Attributes[AttributeName].Value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieves a true of false value from an XML attribute. Returns null-bool if the attribute doesnt exist or the
|
|
/// value is malformed.
|
|
/// </summary>
|
|
/// <param name="Node"></param>
|
|
/// <param name="AttributeName"></param>
|
|
/// <returns></returns>
|
|
public static bool? GetBoolXmlAttribute(XmlNode Node, string AttributeName)
|
|
{
|
|
bool b;
|
|
if (Node.Attributes[AttributeName] == null)
|
|
return null;
|
|
|
|
if (bool.TryParse(Node.Attributes[AttributeName].Value, out b))
|
|
return b;
|
|
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieves a true of false value from an XML attribute. Returns Default if the attribute doesnt exist or the
|
|
/// value is malformed.
|
|
/// </summary>
|
|
/// <param name="Node"></param>
|
|
/// <param name="AttributeName"></param>
|
|
/// <returns></returns>
|
|
public static bool GetBoolXmlAttribute(XmlNode Node, string AttributeName, bool Default)
|
|
{
|
|
bool? b = GetBoolXmlAttribute(Node, AttributeName);
|
|
if (!b.HasValue)
|
|
return Default;
|
|
|
|
return b.Value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieves a float value from an XML attribute. Defaults to null-float if the attribute doesnt exist or the
|
|
/// value is malformed.
|
|
/// </summary>
|
|
/// <param name="Node"></param>
|
|
/// <param name="AttributeName"></param>
|
|
/// <returns></returns>
|
|
public static float? GetFloatXmlAttribute(XmlNode Node, string AttributeName)
|
|
{
|
|
float f;
|
|
if (Node.Attributes[AttributeName] == null)
|
|
return null;
|
|
|
|
if (float.TryParse(Node.Attributes[AttributeName].Value, out f))
|
|
return f;
|
|
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieves a float value from an XML attribute. Returns Default if the attribute doesnt exist or the
|
|
/// value is malformed.
|
|
/// </summary>
|
|
/// <param name="Node"></param>
|
|
/// <param name="AttributeName"></param>
|
|
/// <returns></returns>
|
|
public static float GetFloatXmlAttribute(XmlNode Node, string AttributeName, float Default)
|
|
{
|
|
float? f = GetFloatXmlAttribute(Node, AttributeName);
|
|
if (!f.HasValue)
|
|
return Default;
|
|
|
|
return f.Value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieves an int value from an XML attribute. Defaults to null-int if the attribute doesnt exist or the
|
|
/// value is malformed.
|
|
/// </summary>
|
|
/// <param name="Node"></param>
|
|
/// <param name="AttributeName"></param>
|
|
/// <returns></returns>
|
|
public static int? GetIntXmlAttribute(XmlNode Node, string AttributeName)
|
|
{
|
|
int i;
|
|
if (Node.Attributes[AttributeName] == null)
|
|
return null;
|
|
|
|
if (int.TryParse(Node.Attributes[AttributeName].Value, out i))
|
|
return i;
|
|
|
|
return null;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieves an int value from an XML attribute. Returns Default if the attribute doesnt exist or the
|
|
/// value is malformed.
|
|
/// </summary>
|
|
/// <param name="Node"></param>
|
|
/// <param name="AttributeName"></param>
|
|
/// <returns></returns>
|
|
public static int GetIntXmlAttribute(XmlNode Node, string AttributeName, int Default)
|
|
{
|
|
int? i = GetIntXmlAttribute(Node, AttributeName);
|
|
if (!i.HasValue)
|
|
return Default;
|
|
|
|
return i.Value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieves the string content of an XmlNode attribute or throws an I18NException if it missing.
|
|
/// </summary>
|
|
/// <param name="Node"></param>
|
|
/// <param name="Attribute"></param>
|
|
/// <returns></returns>
|
|
public static string GetXmlAttribute(XmlNode Node, string Attribute)
|
|
{
|
|
if (Node.Attributes[Attribute] == null)
|
|
throw new I18NException(I18NExceptionType.XmlAttributeMissing, Attribute, Node.Name);
|
|
return Node.Attributes[Attribute].Value;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retrieves the enum content of an XmlNode attribute or Default if it is missing.
|
|
///
|
|
/// WARNING: Runtime check that typeof(T).IsEnum (Sorry! C# doesnt support Enum generics very well).
|
|
/// </summary>
|
|
/// <param name="Node"></param>
|
|
/// <param name="Attribute"></param>
|
|
/// <returns></returns>
|
|
public static T GetEnumXmlAttribute<T>(XmlNode Node, string Attribute, T Default)
|
|
{
|
|
if (Node.Attributes[Attribute] == null)
|
|
return Default;
|
|
|
|
System.Diagnostics.Trace.Assert(typeof(T).IsEnum, "Supplied type to GetEnumXmlAttribute is not an enum");
|
|
|
|
try
|
|
{
|
|
T result = (T)Enum.Parse(typeof(T), Node.Attributes[Attribute].Value);
|
|
return result;
|
|
}
|
|
catch
|
|
{
|
|
return Default;
|
|
}
|
|
}
|
|
|
|
public static string PrettyFingerprint(string p)
|
|
{
|
|
List<string> pairs = new List<string>();
|
|
for (int i = 0; i < p.Length; i += 2)
|
|
{
|
|
pairs.Add(p.Substring(i, 2));
|
|
}
|
|
return string.Join(":", pairs.ToArray());
|
|
}
|
|
|
|
|
|
|
|
public static string GetUrl(IXenConnection connection)
|
|
{
|
|
UriBuilder uriBuilder = new UriBuilder(connection.UriScheme, connection.Hostname);
|
|
uriBuilder.Port = connection.Port;
|
|
return uriBuilder.ToString();
|
|
}
|
|
|
|
public static string DefaultVMName(string p, IXenConnection connection)
|
|
{
|
|
for (int i = 1; true; i++)
|
|
{
|
|
bool willDo = true;
|
|
string name = string.Format(Messages.NEWVM_DEFAULTNAME, p, i);
|
|
string hiddenName = Helpers.GuiTempObjectPrefix + name;
|
|
// Check to see if name is in use
|
|
foreach (VM v in connection.Cache.VMs)
|
|
{
|
|
if (v.name_label == name || v.name_label == hiddenName)
|
|
{
|
|
willDo = false;
|
|
break;
|
|
}
|
|
}
|
|
if (willDo) return name;
|
|
}
|
|
}
|
|
|
|
public static bool CDsExist(IXenConnection connection)
|
|
{
|
|
if (connection == null)
|
|
return false;
|
|
|
|
foreach (SR sr in connection.Cache.SRs)
|
|
{
|
|
if (sr.content_type != SR.Content_Type_ISO)
|
|
continue;
|
|
|
|
if (sr.VDIs.Count > 0)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public static object GetListOfNames(List<Host> list)
|
|
{
|
|
List<string> names = new List<string>();
|
|
foreach (Host obj in list)
|
|
{
|
|
names.Add(obj.Name);
|
|
}
|
|
|
|
return string.Join(", ", names.ToArray());
|
|
}
|
|
|
|
public static List<VM> VMsRunningOn(List<Host> hosts)
|
|
{
|
|
List<VM> vms = new List<VM>();
|
|
foreach (Host host in hosts)
|
|
{
|
|
vms.AddRange(host.Connection.ResolveAll(host.resident_VMs));
|
|
}
|
|
return vms;
|
|
}
|
|
|
|
public static bool CompareLists<T>(List<T> l1, List<T> l2)
|
|
{
|
|
if (l1 == l2)
|
|
return true;
|
|
else if (l1 == null || l2 == null)
|
|
return false;
|
|
|
|
bool same = l1.Count == l2.Count;
|
|
foreach (T item in l1)
|
|
{
|
|
if (!l2.Contains(item))
|
|
{
|
|
same = false;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return same;
|
|
}
|
|
|
|
public static bool ListsIntersect<T>(List<T> l1, List<T> l2)
|
|
{
|
|
foreach (T item in l1)
|
|
{
|
|
if (l2.Contains(item))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
public static bool CustomWithNoDVD(VM template)
|
|
{
|
|
return template != null && !template.DefaultTemplate && template.FindVMCDROM() == null;
|
|
}
|
|
|
|
public static string GetMacString(string mac)
|
|
{
|
|
return mac == "" ? Messages.MAC_AUTOGENERATE : mac;
|
|
}
|
|
|
|
public static PIF FindPIF(XenAPI.Network network, Host owner)
|
|
{
|
|
foreach (PIF pif in network.Connection.ResolveAll(network.PIFs))
|
|
{
|
|
if (owner == null ||
|
|
pif.host == owner.opaque_ref)
|
|
return pif;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
public static string VlanString(PIF pif)
|
|
{
|
|
if (pif == null || pif.VLAN == -1)
|
|
return Messages.SPACED_HYPHEN;
|
|
|
|
return pif.VLAN.ToString();
|
|
}
|
|
|
|
|
|
|
|
|
|
/// <summary>
|
|
/// Return a string version of a list, in the form "L1, L2, L3 and L4"
|
|
/// </summary>
|
|
public static string StringifyList<T>(List<T> list)
|
|
{
|
|
if (list == null)
|
|
return String.Empty;
|
|
|
|
StringBuilder ans = new StringBuilder();
|
|
for (int i = 0; i < list.Count; ++i)
|
|
{
|
|
ans.Append(list[i].ToString());
|
|
if (i < list.Count - 2)
|
|
ans.Append(Messages.STRINGIFY_LIST_INNERSEP);
|
|
else if (i == list.Count - 2)
|
|
ans.Append(Messages.STRINGIFY_LIST_LASTSEP);
|
|
}
|
|
return ans.ToString();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Does the connection support Link aggregation (LACP) bonds (i.e., is Tampa or later on the vSwitch backend)?
|
|
/// </summary>
|
|
public static bool SupportsLinkAggregationBond(IXenConnection connection)
|
|
{
|
|
Host master = GetMaster(connection);
|
|
return master != null && TampaOrGreater(master) && master.vSwitchNetworkBackend;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Number of alloowed NICs per bond
|
|
/// </summary>
|
|
public static int BondSizeLimit(IXenConnection connection)
|
|
{
|
|
Host master = GetMaster(connection);
|
|
// For Tampa or later on the vSwitch backend, we allow 4 NICs per bond; otherwise, 2
|
|
return master != null && TampaOrGreater(master) && master.vSwitchNetworkBackend ? 4 : 2;
|
|
}
|
|
|
|
public static Host GetHostAncestor(IXenObject xenObject)
|
|
{
|
|
if (xenObject == null || xenObject.Connection == null)
|
|
return null;
|
|
|
|
if (xenObject is Host)
|
|
return (Host)xenObject;
|
|
|
|
if (xenObject is SR)
|
|
return ((SR)xenObject).Home;
|
|
|
|
if (xenObject is VM)
|
|
{
|
|
VM vm = (VM) xenObject;
|
|
return vm.Home();
|
|
}
|
|
|
|
return null;
|
|
}
|
|
|
|
public static bool SameServerVersion(Host host, string longProductVersion)
|
|
{
|
|
return host != null && host.LongProductVersion == longProductVersion;
|
|
}
|
|
|
|
public static bool EnabledTargetExists(Host host, IXenConnection connection)
|
|
{
|
|
if (host != null)
|
|
return host.enabled;
|
|
|
|
return connection.Cache.Hosts.Any(h => h.enabled);
|
|
}
|
|
|
|
public static bool GpuCapability(IXenConnection connection)
|
|
{
|
|
if (FeatureForbidden(connection, Host.RestrictGpu))
|
|
return false;
|
|
var pool = GetPoolOfOne(connection);
|
|
return pool != null && pool.HasGpu;
|
|
}
|
|
|
|
public static bool VGpuCapability(IXenConnection connection)
|
|
{
|
|
if (FeatureForbidden(connection, Host.RestrictVgpu))
|
|
return false;
|
|
var pool = GetPoolOfOne(connection);
|
|
return pool != null && pool.HasVGpu;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Whether creation of VLAN 0 is allowed.
|
|
/// </summary>
|
|
public static bool VLAN0Allowed(IXenConnection connection)
|
|
{
|
|
Host master = GetMaster(connection);
|
|
// For Creedence or later on the vSwitch backend, we allow creation of VLAN 0
|
|
return master != null && CreedenceOrGreater(master) && master.vSwitchNetworkBackend;
|
|
}
|
|
|
|
public static bool ContainerCapability(IXenConnection connection)
|
|
{
|
|
var master = GetMaster(connection);
|
|
if (master == null)
|
|
return false;
|
|
if (ElyOrGreater(connection))
|
|
return master.AppliedUpdates().Any(update => update.Name.ToLower().StartsWith("xscontainer"));
|
|
return CreamOrGreater(connection) && master.SuppPacks.Any(suppPack => suppPack.Name.ToLower().StartsWith("xscontainer"));
|
|
}
|
|
|
|
public static bool PvsCacheCapability(IXenConnection connection)
|
|
{
|
|
var master = GetMaster(connection);
|
|
return master != null && master.AppliedUpdates().Any(update => update.Name.ToLower().StartsWith("pvsaccelerator"));
|
|
}
|
|
|
|
/// <summary>
|
|
/// This method returns the disk space required (bytes) on the provided SR for the provided VDI.
|
|
/// This method also considers thin provisioning. For thin provisioned SRs the provided sm_config in the VDI will be considered first, or it will use the values from the SR's sm_config in case the VDI does not have these set. For fully provisioned SRs the sm_config in the VDI will be ignored.
|
|
/// </summary>
|
|
/// <returns>Disk size required in bytes.</returns>
|
|
public static long GetRequiredSpaceToCreateVdiOnSr(SR sr, VDI vdi)
|
|
{
|
|
if (sr == null)
|
|
throw new ArgumentNullException("sr");
|
|
|
|
if (vdi == null)
|
|
throw new ArgumentNullException("vdi");
|
|
|
|
if (!sr.IsThinProvisioned)
|
|
return vdi.virtual_size;
|
|
|
|
long initialAllocationVdi = -1;
|
|
if (vdi.sm_config != null && vdi.sm_config.ContainsKey("initial_allocation"))
|
|
long.TryParse(vdi.sm_config["initial_allocation"], out initialAllocationVdi);
|
|
|
|
long initialAllocationSr = -1;
|
|
if (sr.sm_config != null && sr.sm_config.ContainsKey("initial_allocation"))
|
|
long.TryParse(sr.sm_config["initial_allocation"], out initialAllocationSr);
|
|
|
|
if (initialAllocationVdi > -1)
|
|
return initialAllocationVdi;
|
|
|
|
if (initialAllocationSr > -1)
|
|
return initialAllocationSr;
|
|
|
|
return vdi.virtual_size;
|
|
}
|
|
|
|
public static string UrlEncode(this string str)
|
|
{
|
|
if (string.IsNullOrEmpty(str))
|
|
return str;
|
|
|
|
return System.Net.WebUtility.UrlEncode(str);
|
|
}
|
|
}
|
|
}
|