mirror of
https://github.com/xcp-ng/xenadmin.git
synced 2024-12-23 08:56:02 +01:00
15ef3410a3
Signed-off-by: Cheng Zhang <cheng.zhang@citrix.com>
238 lines
8.9 KiB
C#
238 lines
8.9 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 XenAdmin.Core;
|
|
using System.IO;
|
|
using System.Threading;
|
|
using System.Text.RegularExpressions;
|
|
|
|
|
|
namespace XenAdmin.Actions
|
|
{
|
|
public class SystemStatusAction : AsyncAction
|
|
{
|
|
private static readonly log4net.ILog log = log4net.LogManager.GetLogger(System.Reflection.MethodBase.GetCurrentMethod().DeclaringType);
|
|
|
|
private readonly List<HostWithStatus> hosts;
|
|
private readonly List<string> entries;
|
|
|
|
private List<SingleHostStatusAction> actions = new List<SingleHostStatusAction>();
|
|
|
|
public bool SomethingToSave = false;
|
|
private Object completeActionsMonitor = new Object();
|
|
|
|
public SystemStatusAction(List<HostWithStatus> hosts,
|
|
List<string> entries)
|
|
: base(null, Messages.ACTION_SYSTEM_STATUS_TITLE, null)
|
|
{
|
|
this.hosts = hosts;
|
|
this.entries = entries;
|
|
}
|
|
|
|
protected override void Run()
|
|
{
|
|
int n = hosts.Count;
|
|
string filepath = Path.Combine(Path.GetTempPath(), Path.GetRandomFileName());
|
|
|
|
if (Directory.Exists(filepath))
|
|
Directory.Delete(filepath);
|
|
Directory.CreateDirectory(filepath);
|
|
|
|
string timestring = DateTime.Now.ToString("yyyy-MM-dd-HH-mm-ss");
|
|
|
|
// Copy client logs
|
|
string logDestination = string.Format("{0}\\{1}-{2}", filepath, timestring, InvisibleMessages.LOG_FILENAME);
|
|
if (entries.Contains("client-logs"))
|
|
{
|
|
if (File.Exists(logDestination))
|
|
File.Delete(logDestination);
|
|
string logPath = XenAdminConfigManager.Provider.GetLogFile();
|
|
File.Copy(logPath, logDestination);
|
|
// Copy old XenCenter.log.* files too
|
|
DirectoryInfo di = new DirectoryInfo(Path.GetDirectoryName(logPath));
|
|
Regex regex = new Regex(Regex.Escape(Path.GetFileName(logPath)) + @"\.\d+");
|
|
foreach (FileInfo file in di.GetFiles())
|
|
{
|
|
if (regex.IsMatch(file.Name))
|
|
File.Copy(file.FullName, Path.Combine(filepath, timestring + "-" + file.Name));
|
|
}
|
|
}
|
|
// collect all master/slave information to output as a separate text file with the report
|
|
List<string> mastersInfo = new List<string>();
|
|
|
|
int completedActions = hosts.Count;
|
|
|
|
int i = 0;
|
|
foreach (HostWithStatus host in hosts)
|
|
{
|
|
Description = string.Format(Messages.ACTION_SYSTEM_STATUS_DESCRIPTION, host.Host.Name);
|
|
Pool = Helpers.GetPoolOfOne(host.Host.Connection);
|
|
// master/slave information
|
|
XenAPI.Pool p = Helpers.GetPool(host.Host.Connection);
|
|
if (p == null)
|
|
{
|
|
mastersInfo.Add(string.Format("Server '{0}' is a stand alone server",
|
|
host.Host.Name));
|
|
}
|
|
else
|
|
{
|
|
mastersInfo.Add(string.Format("Server '{0}' is a {1} of pool '{2}'",
|
|
host.Host.Name,
|
|
p.master.opaque_ref == host.Host.opaque_ref ? "master" : "slave",
|
|
p.Name));
|
|
}
|
|
|
|
// Ensure downloaded filenames are unique even for hosts with the same hostname: append a counter to the timestring
|
|
SingleHostStatusAction action = new SingleHostStatusAction(host, entries, filepath, timestring + "-" + ++i);
|
|
actions.Add(action);
|
|
action.Changed += (Action<ActionBase>)delegate
|
|
{
|
|
int total = 0;
|
|
|
|
foreach (SingleHostStatusAction a in actions)
|
|
{
|
|
total += a.PercentComplete;
|
|
}
|
|
|
|
PercentComplete = (int)(total / n);
|
|
};
|
|
action.Completed += (Action<ActionBase>)delegate
|
|
{
|
|
lock (completeActionsMonitor)
|
|
{
|
|
completedActions--;
|
|
Monitor.PulseAll(completeActionsMonitor);
|
|
}
|
|
};
|
|
action.RunAsync();
|
|
}
|
|
|
|
// output the slave/master info while we wait
|
|
string mastersDestination = string.Format("{0}\\{1}-Masters.txt", filepath, timestring);
|
|
if (File.Exists(mastersDestination))
|
|
File.Delete(mastersDestination);
|
|
|
|
StreamWriter sw = null;
|
|
try
|
|
{
|
|
sw = new StreamWriter(mastersDestination);
|
|
foreach (string s in mastersInfo)
|
|
sw.WriteLine(s);
|
|
|
|
sw.Flush();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
log.ErrorFormat("Exception while writing masters file: {0}", e);
|
|
}
|
|
finally
|
|
{
|
|
if (sw != null)
|
|
sw.Close();
|
|
}
|
|
|
|
// now wait for the status actions to return
|
|
lock (completeActionsMonitor)
|
|
while (completedActions > 0 && !Cancelling)
|
|
Monitor.Wait(completeActionsMonitor);
|
|
|
|
if (Cancelling)
|
|
throw new CancelledException();
|
|
|
|
int failedHosts = 0;
|
|
|
|
foreach (HostWithStatus h in hosts)
|
|
{
|
|
if (h.Status == HostStatus.failed)
|
|
failedHosts++;
|
|
else
|
|
SomethingToSave = true;
|
|
}
|
|
|
|
Result = filepath;
|
|
if (Cancelling || Cancelled)
|
|
Description = Messages.ACTION_SYSTEM_STATUS_CANCELLED;
|
|
else if (failedHosts > 0)
|
|
{
|
|
if (failedHosts == hosts.Count)
|
|
{
|
|
if (entries.Contains("client-logs"))
|
|
{
|
|
SomethingToSave = true;
|
|
Description = Messages.ACTION_SYSTEM_STATUS_SUCCESSFUL_WITH_ERRORS_XCLOGS;
|
|
}
|
|
else
|
|
Description = Messages.ACTION_SYSTEM_STATUS_NONE_SUCCEEDED;
|
|
}
|
|
else
|
|
Description = Messages.ACTION_SYSTEM_STATUS_SUCCESSFUL_WITH_ERROR;
|
|
}
|
|
else
|
|
Description = Messages.ACTION_SYSTEM_STATUS_SUCCESSFUL;
|
|
}
|
|
|
|
public override void RecomputeCanCancel()
|
|
{
|
|
if (this.IsCompleted)
|
|
{
|
|
CanCancel = false;
|
|
return;
|
|
}
|
|
|
|
foreach (SingleHostStatusAction action in actions)
|
|
{
|
|
if (!action.IsCompleted)
|
|
{
|
|
CanCancel = true;
|
|
return;
|
|
}
|
|
}
|
|
|
|
CanCancel = false;
|
|
}
|
|
|
|
protected override void CancelRelatedTask()
|
|
{
|
|
foreach (SingleHostStatusAction action in actions)
|
|
{
|
|
action.Cancel();
|
|
}
|
|
|
|
lock (completeActionsMonitor)
|
|
Monitor.PulseAll(completeActionsMonitor);
|
|
|
|
Description = Messages.ACTION_SYSTEM_STATUS_CANCELLED;
|
|
}
|
|
}
|
|
}
|