public static string GetTableFromResource(PveClient client, string resource)
{
var result = client.Get(resource);
var ret = "";
if (!result.IsSuccessStatusCode)
{
ret = result.ReasonPhrase;
}
else
{
var returnParameters = GetClassApiReturnParameters(resource);
if (returnParameters == null || returnParameters.Count == 0)
{
ret = TableHelper.CreateTable(result.Response.data);
}
else
{
var keys = returnParameters.OrderBy(a => a.Optional)
.ThenBy(a => a.Name)
.Select(a => a.Name)
.ToArray();
ret = TableHelper.CreateTable(result.Response.data, keys, returnParameters);
}
}
return(ret);
}
/// <summary> /// Return all nodes info. /// </summary> /// <param name="client"></param> /// <returns></returns> public static IReadOnlyList <NodeInfo> GetNodes(this PveClient client) => client.Nodes.GetRest() .ToEnumerable() .Select(a => new NodeInfo(client, a)) .OrderBy(a => a.Node) .ToList() .AsReadOnly();
/// <summary>
/// List structure
/// </summary>
/// <param name="client"></param>
/// <param name="classApiRoot"></param>
/// <param name="resource"></param>
/// <returns></returns>
public static string List(PveClient client, ClassApi classApiRoot, string resource)
{
var(Values, Error) = ListValues(client, classApiRoot, resource);
return(string.Join(Environment.NewLine, Values.Select(a => $"{a.Attribute} {a.Value}")) +
(string.IsNullOrWhiteSpace(Error) ? "" : Environment.NewLine + Error) +
Environment.NewLine);
}
public static PveClient GetClient()
{
var client = new PveClient(Host, Port);
client.Login(Username, Password);
return(client);
}
/// <summary>
/// Create file for SPICE client
/// </summary>
/// <param name="client"></param>
/// <param name="vmIdOrName"></param>
/// <param name="fileName"></param>
/// <returns></returns>
public static bool CreateFileSpaceClient(this PveClient client, string vmIdOrName, string fileName)
{
var ret = false;
var vm = client.GetVM(vmIdOrName);
if (vm != null && vm.Type == VMTypeEnum.Qemu)
{
var response = vm.QemuApi.Spiceproxy.Spiceproxy(client.Hostname);
if (response.IsSuccessStatusCode)
{
var data = response.Response.data;
var contests = $@"[virt-viewer]
host={data.host}
delete-this-file={DynamicHelper.GetValue(data, "delete-this-file")}
password={data.password}
title={data.title}
secure-attention={DynamicHelper.GetValue(data, "secure-attention")}
toggle-fullscreen={DynamicHelper.GetValue(data, "toggle-fullscreen")}
tls-port={DynamicHelper.GetValue(data, "tls-port")}
type={data.type}
release-cursor={DynamicHelper.GetValue(data, "release-cursor")}
host-subject={DynamicHelper.GetValue(data, "host-subject")}
proxy={data.proxy}
ca={data.ca}
";
File.WriteAllText(fileName, contests);
ret = true;
}
}
return(ret);
}
internal StorageInfo(PveClient client, object apiData, StorageTypeEnum type) : base(client, apiData)
{
Type = type;
DynamicHelper.CheckKeyOrCreate(apiData, "disable", "0");
DynamicHelper.CheckKeyOrCreate(apiData, "nodes", "All");
Nodes = ApiData.nodes.Split(',');
}
/// <summary>
/// Get all vms info.
/// </summary>
/// <param name="client"></param>
/// <returns></returns>
public static VMInfo[] GetVMs(this PveClient client)
{
var vms = new List <VMInfo>();
foreach (var vm in client.Cluster.Resources.GetRest("vm").Response.data)
{
vms.Add(new VMInfo(client, vm));
}
return(vms.OrderBy(a => a.Node).ThenBy(a => a.Id).ToArray());
}
/// <summary>
/// Get vm info from id or name.
/// </summary>
/// <param name="client"></param>
/// <param name="idOrName"></param>
/// <returns></returns>
public static VMInfo GetVM(this PveClient client, string idOrName)
{
var vm = GetVMs(client).Where(a => CheckIdOrName(a, idOrName)).FirstOrDefault();
if (vm == null)
{
throw new ArgumentException($"VM/CT {idOrName} not found!");
}
return(vm);
}
/// <summary>
/// Return node info from id.
/// </summary>
/// <param name="client"></param>
/// <param name="name"></param>
/// <returns></returns>
public static NodeInfo GetNode(this PveClient client, string name)
{
var node = GetNodes(client).Where(a => a.Node == name).FirstOrDefault();
if (node == null)
{
throw new ArgumentException($"Node {name} not found!");
}
return(node);
}
/// <summary>
/// Return all nodes info.
/// </summary>
/// <param name="client"></param>
/// <returns></returns>
public static IReadOnlyList <NodeInfo> GetNodes(this PveClient client)
{
var nodes = new List <NodeInfo>();
foreach (var node in client.Nodes.GetRest().Response.data)
{
nodes.Add(new NodeInfo(client, node));
}
return(nodes.OrderBy(a => a.Node).ToList().AsReadOnly());
}
/// <summary>
/// Sub commands
/// </summary>
/// <param name="parent"></param>
/// <param name="client"></param>
/// <param name="classApiRoot"></param>
internal static void SumCommands(CommandLineApplication parent,
PveClient client,
ClassApi classApiRoot)
{
Execute(parent, MethodType.Get, "Get (GET) from resource", client, classApiRoot);
Execute(parent, MethodType.Set, "Set (PUT) from resource", client, classApiRoot);
Execute(parent, MethodType.Create, "Create (POST) from resource", client, classApiRoot);
Execute(parent, MethodType.Delete, "Delete (DELETE) from resource", client, classApiRoot);
Usage(parent, classApiRoot);
List(parent, client, classApiRoot);
}
private static void CreateCommandFromAlias(TextWriter output,
CommandLineApplication parent,
PveClient client,
ClassApi classApiRoot,
AliasManager aliasManager,
bool onlyResult)
{
foreach (var item in aliasManager.Alias)
{
parent.Command(item.Names[0], cmd =>
{
foreach (var name in item.Names)
{
cmd.AddName(name);
}
cmd.Description = item.Description;
cmd.ShowInHelpText = false;
cmd.ExtendedHelpText = Environment.NewLine + "Alias command: " + item.Command;
//create argument
foreach (var arg in StringHelper.GetArgumentTags(item.Command))
{
cmd.Argument(arg, arg, false).IsRequired();
}
cmd.OnExecute(() =>
{
var title = item.Description;
var command = item.Command;
//replace value into argument
foreach (var arg in cmd.Arguments)
{
title += $" {arg.Name}: {arg.Value}";
command = command.Replace(StringHelper.CreateArgumentTag(arg.Name), arg.Value);
}
if (!onlyResult)
{
output.WriteLine(title);
output.WriteLine("Command: " + command);
}
ParseLine(output,
command,
client,
classApiRoot,
aliasManager,
onlyResult);
});
});
}
}
/// <summary>
/// Get vms from jolly.
/// </summary>
/// <param name="client"></param>
/// <param name="jolly">all for all vm,
/// <para>all-nodename all vm in host,</para>
/// <para>vmid id vm</para>
/// <para>Range 100:104 return vm with id in range</para>
/// <para>start with '-' exclude vm</para>
/// <para>comma reparated</para>
/// </param>
/// <returns></returns>
public static VMInfo[] GetVMs(this PveClient client, string jolly)
{
var allVms = GetVMs(client);
var ret = new List <VMInfo>();
foreach (var id in jolly.Split(','))
{
if (id == "all" || id == "@all")
{
//all nodes
ret.AddRange(allVms);
}
else if (id.StartsWith("all-") || id.StartsWith("@all-"))
{
//all in specific node
var idx = id.StartsWith("all-") ? 4 : 5;
ret.AddRange(allVms.Where(a => a.Node.ToLower() == id.ToLower().Substring(idx)));
}
else if (id.StartsWith("@pool-"))
{
//all in specific pool
var poolName = id.ToLower().Substring(6);
var result = client.Pools[poolName].GetRest();
if (result.IsSuccessStatusCode)
{
foreach (var item in result.Response.data.members)
{
if (item.type == "qemu" || item.type == "lxc")
{
ret.Add(allVms.Where(a => a.Id == item.vmid + "").SingleOrDefault());
}
}
}
}
else
{
ret.AddRange(allVms.Where(a => VmCheckIdOrName(a, id)));
}
}
ret = ret.Distinct().ToList();
//exclude data
foreach (var id in jolly.Split(',').Where(a => a.StartsWith("-")).Select(a => a.Substring(1)))
{
foreach (var item in allVms.Where(a => VmCheckIdOrName(a, id)))
{
ret.Remove(item);
}
}
return(ret.ToArray());
}
private static void List(CommandLineApplication parent, PveClient client, ClassApi classApiRoot)
{
parent.Command("ls", cmd =>
{
cmd.Description = "List child objects on <api_path>.";
cmd.AddFullNameLogo();
var argResource = CreateResourceArgument(cmd);
cmd.OnExecute(() => Console.Out.Write(ApiExplorer.List(client ?? cmd.ClientTryLogin(),
classApiRoot ?? GetClassApiRoot(parent),
argResource.Value)));
});
}
internal Disk(PveClient client, string id, string definition)
{
Client = client;
Id = id;
Definition = definition;
Backup = true;
var data = definition.Split(':');
Storage = data[0];
data = data[1].Split(',');
Name = data[0];
Size = data.Where(a => a.StartsWith("size=")).Select(a => a.Substring(5)).FirstOrDefault();
}
/// <summary>
/// Try login client api
/// </summary>
/// <param name="command"></param>
/// <returns></returns>
public static PveClient ClientTryLogin(this CommandLineApplication command)
{
var error = "Problem connection!";
foreach (var host in GetHostAndPort(command))
{
using (var ping = new Ping())
{
if (ping.Send(host.Host).Status != IPStatus.Success)
{
if (command.DebugIsActive())
{
command.Out.WriteLine($"Error: try login unknown host {host.Host}");
}
continue;
}
}
try
{
var client = new PveClient(host.Host, host.Port);
//check enable debug
if (command.DebugIsActive())
{
client.DebugLevel = 99;
}
//try login
if (client.Login(command.GetOption(USERNAME_OPTION_NAME, true).Value(),
GetPasswordFromOption(command)))
{
return(client);
}
if (!client.LastResult.IsSuccessStatusCode)
{
error += " " + client.LastResult.ReasonPhrase;
}
}
catch { }
}
throw new ApplicationException(error);
}
/// <summary>
/// Get vms from jolly.
/// </summary>
/// <param name="client"></param>
/// <param name="jolly">all for all vm,
/// <para>all-nodename all vm in host,</para>
/// <para>vmid id vm</para>
/// <para>start with '-' exclude vm</para>
/// <para>comma reparated</para></param>
/// <returns></returns>
public static VMInfo[] GetVMs(this PveClient client, string jolly)
{
var allVms = GetVMs(client);
var ret = new List <VMInfo>();
foreach (var id in jolly.Split(','))
{
if (id == "all")
{
//all nodes
ret.AddRange(allVms);
}
else if (id.StartsWith("all-"))
{
//all in specific node
ret.AddRange(allVms.Where(a => a.Node.ToLower() == id.ToLower().Substring(4)));
}
else
{
//specific id
var vm = allVms.Where(a => VmCheckIdOrName(a, id)).FirstOrDefault();
if (vm != null)
{
ret.Add(vm);
}
}
}
//exclude data
foreach (var id in jolly.Split(',').Where(a => a.StartsWith("-")).Select(a => a.Substring(1)))
{
var vm = allVms.Where(a => VmCheckIdOrName(a, id)).FirstOrDefault();
if (vm != null)
{
ret.Remove(vm);
}
}
return(ret.Distinct().ToArray());
}
private static void Run(Options option)
{
var builder = new HostBuilder()
.UseConsoleLifetime();
var host = builder.Build();
using var serviceScope = host.Services.CreateScope();
{
var services = serviceScope.ServiceProvider;
try
{
var client = new PveClient(option.Host, option.Port);
if (!client.Login(option.Username, option.Password))
{
return;
}
if (option.isDebugger)
{
Console.WriteLine($"Connect to PVE[{option.Host}] with {option.Username}");
}
foreach (var vm in client.GetVMs())
{
vm.LxcApi.Vncproxy.CreateRest();
if (option.isDebugger)
{
Console.WriteLine($"Connect to [{vm.Node}]'s VM {vm.Name} ...{vm.Status}");
}
}
}
catch (Exception ex)
{
var logger = services.GetRequiredService <ILogger <Program> >();
logger.LogError(ex, "An error occurred.");
}
}
}
private static void Execute(CommandLineApplication parent,
MethodType methodType,
string description,
PveClient client,
ClassApi classApiRoot)
{
parent.Command(methodType.ToString().ToLower(), cmd =>
{
cmd.Description = description;
cmd.AddFullNameLogo();
var optVerbose = cmd.VerboseOption();
var argResource = CreateResourceArgument(cmd);
var argParameters = cmd.Argument("parameters",
"Parameter for resource format key:value (Multiple)." +
" If value have space or special charapter using quote 'key:value'",
true);
var optOutput = cmd.OptionEnum <ApiExplorer.OutputType>("--output|-o", "Type output (default: unicode)");
var optWait = cmd.WaitOption();
cmd.OnExecute(() =>
{
client = client ?? parent.ClientTryLogin();
classApiRoot = classApiRoot ?? GetClassApiRoot(client);
var ret = ApiExplorer.Execute(client,
classApiRoot,
argResource.Value,
methodType,
ApiExplorer.CreateParameterResource(argParameters.Values),
optWait.HasValue(),
optOutput.GetEnumValue <ApiExplorer.OutputType>(),
optVerbose.HasValue());
parent.Out.Write(ret.ResultText);
return(ret.ResultCode);
});
});
}
/// <summary>
/// Get all astorage client.
/// </summary>
/// <param name="client"></param>
/// <returns></returns>
public static IReadOnlyList <StorageInfo> GetStorages(this PveClient client)
{
var storages = new List <StorageInfo>();
foreach (var apiData in client.Storage.GetRest().Response.data)
{
switch (apiData.type)
{
case "rbd": storages.Add(new Rbd(client, apiData)); break;
case "dir": storages.Add(new Dir(client, apiData)); break;
case "nfs": storages.Add(new NFS(client, apiData)); break;
case "zfs": storages.Add(new ZFS(client, apiData)); break;
// cephfs cifs drbd glusterfs iscsi
// iscsidirect lvm lvmthin zfspool
default: storages.Add(new Unknown(client, apiData)); break;
}
}
return(storages.AsReadOnly());
}
public static ClassApi GetClassApiRoot(PveClient client) => _classApiRoot ??= GeneretorClassApi.Generate(client.Hostname, client.Port);
internal DiskQemu(PveClient client, string id, string definition) : base(client, id, definition)
{
var backup = definition.Split(':')[1].Split(',').Where(a => a.StartsWith("backup=")).FirstOrDefault();
Backup = backup == null ? true : backup == "1";
}
/// <summary>
/// Return node info from id.
/// </summary>
/// <param name="client"></param>
/// <param name="name"></param>
/// <returns></returns>
public static NodeInfo GetNode(this PveClient client, string name)
=> GetNodes(client).Where(a => a.Node == name).FirstOrDefault() ??
throw new ArgumentException($"Node '{name}' not found!");
internal VMInfo(PveClient client, object apiData) : base(client, apiData)
{
}
private static ClassApi GetClassApiRoot(PveClient client) => GeneretorClassApi.Generate(client.Hostname, client.Port);
private static bool ParseLine(string input,
PveClient client,
ClassApi classApiRoot,
AliasManager aliasManager,
bool onlyResult)
{
if (string.IsNullOrWhiteSpace(input))
{
return(false);
}
input = input.Trim();
//comment
if (input.StartsWith("#"))
{
return(false);
}
using (var app = new CommandLineApplication())
{
var exit = false;
app.Name = "";
app.Description = "Corsinvest Interactive Shell API for Proxmox VE";
app.DebugOption();
app.DryRunOption();
app.UsePagerForHelpText = false;
app.HelpOption(true);
ShellCommands.SumCommands(app, client, classApiRoot);
//fix help text
foreach (var command in app.Commands)
{
command.FullName = app.Description;
command.ExtendedHelpText = "";
command.UsePagerForHelpText = false;
}
//create command from alias
CreateCommandFromAlias(app, client, classApiRoot, aliasManager, onlyResult);
#region Commands base
app.Command("quit", cmd =>
{
cmd.AddName("exit");
cmd.Description = "Close application";
cmd.OnExecute(() => exit = true);
});
app.Command("clear", cmd =>
{
cmd.AddName("cls");
cmd.Description = "Clear screen";
cmd.OnExecute(() => Console.Clear());
});
app.Command("help", cmd =>
{
cmd.Description = "Show help information";
cmd.OnExecute(() => app.ShowHelp());
});
CmdAlias(app, aliasManager);
CmdHistory(app, onlyResult);
#endregion
app.OnExecute(() => app.ShowHint());
//execute command
try { app.Execute(StringHelper.TokenizeCommandLineToList(input).ToArray()); }
catch (CommandParsingException ex) { Console.Out.WriteLine(ex.Message); }
catch (Exception) { }
return(exit);
}
}
/// <summary>
/// Start interactive shell
/// </summary>
/// <param name="client"></param>
/// <param name="fileScript"></param>
/// <param name="onlyResult"></param>
public static void Start(PveClient client, string fileScript, bool onlyResult)
{
if (!onlyResult)
{
Console.Out.WriteLine($@"Corsinvest Interactive Shell for Proxmox VE ({DateTime.Now.ToLongDateString()})
Type '<TAB>' for completion word
Type 'help', 'quit' or 'CTRL+C' to close the application.");
}
#region ClassApi Metadata
var watch = Stopwatch.StartNew();
if (!onlyResult)
{
Console.Out.Write("Initialization metadata...");
}
//get api metadata
var classApiRoot = GeneretorClassApi.Generate(client.Hostname, client.Port);
watch.Stop();
if (!onlyResult)
{
Console.Out.WriteLine($" {watch.ElapsedMilliseconds}ms");
}
#endregion
if (!onlyResult)
{
Console.Out.WriteLine(Environment.NewLine + ShellHelper.REMEMBER_THESE_THINGS);
}
//Auto Completion
ReadLine.AutoCompletionHandler = new AutoCompletionHandler()
{
Client = client,
ClassApiRoot = classApiRoot
};
LoadHistory();
var aliasManager = new AliasManager()
{
FileName = Path.Combine(ShellHelper.GetApplicationDataDirectory(Program.APP_NAME), "alias.txt")
};
aliasManager.Load();
if (File.Exists(fileScript))
{
//script file
foreach (var line in File.ReadAllLines(fileScript))
{
ParseLine(line, client, classApiRoot, aliasManager, onlyResult);
}
}
else
{
//Interactive
while (true)
{
var input = ReadLine.Read(">>> ");
var exit = ParseLine(input, client, classApiRoot, aliasManager, onlyResult);
SaveHistory();
aliasManager.Save();
if (exit)
{
break;
}
}
}
}
internal Dir(PveClient client, object apiData) : base(client, apiData, StorageTypeEnum.Dir)
{
}
/// <summary>
/// Get all vms info.
/// </summary>
/// <param name="client"></param>
/// <returns></returns>
public static VMInfo[] GetVMs(this PveClient client)
=> client.Cluster.Resources.GetRest("vm").ToEnumerable()
.Select(a => new VMInfo(client, a))
.OrderBy(a => a.Node)
.ThenBy(a => a.Id)
.ToArray();
/// <summary>
/// Get vm info from id or name.
/// </summary>
/// <param name="client"></param>
/// <param name="idOrName"></param>
/// <returns></returns>
public static VMInfo GetVM(this PveClient client, string idOrName)
=> GetVMs(client).Where(a => VmCheckIdOrName(a, idOrName)).FirstOrDefault() ??
throw new ArgumentException($"VM/CT '{idOrName}' not found!");
