// Copyright Keysight Technologies 2012-2019
|
// This Source Code Form is subject to the terms of the Mozilla Public
|
// License, v. 2.0. If a copy of the MPL was not distributed with this
|
// file, you can obtain one at http://mozilla.org/MPL/2.0/.
|
using System;
|
using System.Collections.Generic;
|
using System.Globalization;
|
using System.Reflection;
|
using System.Linq;
|
using System.IO;
|
using System.Diagnostics;
|
using System.Runtime.CompilerServices;
|
using System.Xml.Linq;
|
using System.Text;
|
|
namespace OpenTap.Cli
|
{
|
internal class CliActionTree
|
{
|
public string Name { get; }
|
public bool IsGroup => (SubCommands?.Count ?? 0) > 0;
|
public bool IsBrowsable => (Type?.IsBrowsable() ?? false) || SubCommands.Any(x => x.IsBrowsable);
|
|
public ITypeData Type { get; private set; }
|
public List<CliActionTree> SubCommands { get; private set; }
|
|
public CliActionTree Root { get; }
|
|
public CliActionTree()
|
{
|
var commands = TypeData.GetDerivedTypes(TypeData.FromType(typeof(ICliAction)))
|
.Where(t => t.CanCreateInstance && t.GetDisplayAttribute() != null).ToList();
|
Name = "tap";
|
Root = this;
|
foreach (var item in commands)
|
ParseCommand(item, item.GetDisplayAttribute().Group, Root);
|
}
|
|
CliActionTree(CliActionTree parent, string name)
|
{
|
Name = name;
|
}
|
|
private static void ParseCommand(ITypeData type, string[] group, CliActionTree command)
|
{
|
if (command.SubCommands == null)
|
command.SubCommands = new List<CliActionTree>();
|
|
// If group is not empty. Find command with first group name
|
if (group.Length > 0)
|
{
|
var existingCommand = command.SubCommands.FirstOrDefault(c => c.Name == group[0]);
|
|
if (existingCommand == null)
|
{
|
existingCommand = new CliActionTree(command, group[0]);
|
command.SubCommands.Add(existingCommand);
|
}
|
|
ParseCommand(type, group.Skip(1).ToArray(), existingCommand);
|
}
|
else
|
{
|
command.SubCommands.Add(new CliActionTree(command, type.GetDisplayAttribute().Name) { Type = type, SubCommands = new List<CliActionTree>()});
|
command.SubCommands.Sort((x,y) => string.Compare(x.Name, y.Name));
|
}
|
}
|
|
public CliActionTree GetSubCommand(string[] args)
|
{
|
if (args.Length == 0)
|
return null;
|
|
foreach (var item in SubCommands)
|
{
|
if (item.Name == args[0])
|
{
|
if (args.Length == 1 || item.SubCommands.Any() == false)
|
return item;
|
var subCmd = item.GetSubCommand(args.Skip(1).ToArray());
|
return subCmd ?? item;
|
}
|
}
|
|
return null;
|
}
|
|
/// <summary>
|
/// This method calculates the max length in a command tree. Consider the tree outputted by tap help:
|
/// run
|
/// package
|
/// create
|
/// install = Longest command (10 characters), this method would return the integer 10.
|
/// </summary>
|
/// <param name="levelPadding">How much is each level indenting? In the example above, the subcommands to 'package' is indented with 3 characters</param>
|
/// <returns>Max character length of commands outputted</returns>
|
internal int GetMaxCommandTreeLength(int levelPadding)
|
{
|
var initial = this == Root ? 0 : levelPadding;
|
var x = 0;
|
|
if (SubCommands.Count == 0)
|
return x + Name.Length;
|
|
foreach(var cmd in SubCommands)
|
{
|
int length = cmd.GetMaxCommandTreeLength(levelPadding);
|
if (length > x)
|
x = length;
|
}
|
return x + initial;
|
}
|
}
|
|
/// <summary>
|
/// Helper used to execute <see cref="ICliAction"/>s.
|
/// </summary>
|
public class CliActionExecutor
|
{
|
internal static ITypeData SelectedAction = null;
|
internal static readonly int LevelPadding = 3;
|
private static TraceSource log = Log.CreateSource("tap");
|
private static void CurrentDomain_UnhandledException(object sender, UnhandledExceptionEventArgs e)
|
{
|
if (e.ExceptionObject is Exception ex)
|
{
|
log.Error("CurrentDomain Unhandled Exception: " + ex.Message);
|
log.Debug(ex);
|
log.Flush();
|
}
|
}
|
|
/// <summary>
|
/// Used as command line interface of OpenTAP (PluginManager must have searched for assemblies before this method is called).
|
/// This calls Execute with commandline arguments given to this environment and sets Environment.ExitCode.
|
/// </summary>
|
public static void Execute(){
|
Environment.ExitCode = Execute(Environment.GetCommandLineArgs().Skip(1).ToArray());
|
}
|
|
/// <summary>
|
/// Used as entrypoint for the command line interface of OpenTAP (PluginManager must have searched for assemblies before this method is called)
|
/// </summary>
|
[MethodImpl(MethodImplOptions.NoInlining)]
|
public static int Execute(params string[] args)
|
{
|
try
|
{
|
// Turn off the default system behavior when CTRL+C is pressed.
|
// When Console.TreatControlCAsInput is false, CTRL+C is treated as an interrupt instead of as input.
|
// Assigning to this property while the property is running in the background will cause it to be suspended until
|
// it becomes the foreground process. Therefore we should only assign it if it is not already set to false
|
if (Console.TreatControlCAsInput)
|
Console.TreatControlCAsInput = false;
|
}
|
catch { }
|
var execThread = TapThread.Current;
|
|
void abort()
|
{
|
execThread.AbortNoThrow();
|
}
|
|
Console.CancelKeyPress += (s, e) =>
|
{
|
e.Cancel = true;
|
abort();
|
};
|
// Signals are not supported on Windows.
|
if (OperatingSystem.Current != OperatingSystem.Windows)
|
{
|
PosixSignals.SignalCallback handler = context =>
|
{
|
abort();
|
context.Cancel = true;
|
};
|
PosixSignals.AddSignalHandler(PosixSignals.SIGINT, handler);
|
PosixSignals.AddSignalHandler(PosixSignals.SIGTERM, handler);
|
}
|
|
CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
|
CultureInfo.DefaultThreadCurrentCulture = CultureInfo.InvariantCulture;
|
|
AppDomain.CurrentDomain.UnhandledException += CurrentDomain_UnhandledException;
|
|
// Find the called action
|
if(!TypeData.GetDerivedTypes<ICliAction>().Any())
|
{
|
Console.WriteLine("No commands found. Please try reinstalling OpenTAP.");
|
return (int)ExitCodes.UnknownCliAction;
|
}
|
|
try
|
{
|
// setup logging to be relative to the executing assembly.
|
// at this point SessionLogs.Initialize has already been called (PluginManager.Load).
|
// so the log is already being saved at a different location.
|
var logpath = EngineSettings.Current.SessionLogPath.Expand(date: Process.GetCurrentProcess().StartTime);
|
bool isPathRooted = Path.IsPathRooted(logpath);
|
if (isPathRooted == false)
|
{
|
var dir = ExecutorClient.ExeDir;
|
logpath = Path.Combine(dir, logpath);
|
}
|
|
SessionLogs.Rename(logpath);
|
}
|
catch (Exception e)
|
{
|
log.Error("Path defined in Engine settings contains invalid characters: {0}", EngineSettings.Current.SessionLogPath);
|
log.Debug(e);
|
}
|
|
// Find selected command
|
var actionTree = new CliActionTree();
|
var selectedcmd = actionTree.GetSubCommand(args);
|
if (selectedcmd?.Type != null && selectedcmd?.SubCommands.Any() != true)
|
SelectedAction = selectedcmd.Type;
|
|
// Run check for update
|
TapThread.Start(() =>
|
{
|
TapThread.Sleep(3000); // don't spend time on update checking for very short running actions (e.g. 'tap package list -i')
|
try
|
{
|
var checkUpdatesCommands = actionTree.GetSubCommand(["package", "check-updates"]);
|
var checkUpdateAction = checkUpdatesCommands?.Type?.CreateInstance() as ICliAction;
|
if (SelectedAction != checkUpdatesCommands?.Type)
|
checkUpdateAction?.PerformExecute(["--startup"]);
|
}
|
catch (Exception e)
|
{
|
log.Error(e);
|
}
|
});
|
|
void print_command(CliActionTree cmd, int level, int descriptionStart)
|
{
|
if (cmd.IsBrowsable)
|
{
|
// Calculate amount of characters to pad right before description start to ensure description alignments.
|
int relativePadding = level * LevelPadding;
|
|
var sb = new StringBuilder();
|
sb.Append("".PadRight(relativePadding));
|
sb.Append(cmd.Name.PadRight(descriptionStart - relativePadding));
|
|
if (cmd.Type?.IsBrowsable() ?? false)
|
{
|
sb.Append(cmd.Type.GetDisplayAttribute().Description);
|
}
|
|
log.Info(sb.ToString());
|
|
if (cmd.IsGroup)
|
{
|
foreach (var subCmd in cmd.SubCommands)
|
{
|
print_command(subCmd, level + 1, descriptionStart);
|
}
|
}
|
}
|
}
|
|
// Print default info
|
if (SelectedAction == null)
|
{
|
string getVersion()
|
{
|
// We cannot access the 'OpenTap.Package.Installation.Current' from Engine. Parse the XML instead.
|
var xmlFile = Path.Combine(ExecutorClient.ExeDir, "Packages", "OpenTAP", "package.xml");
|
if (File.Exists(xmlFile))
|
{
|
try
|
{
|
var pkg = XElement.Load(xmlFile);
|
if (pkg.Attribute("Version") is XAttribute x) return x.Value;
|
}
|
catch
|
{
|
// This is fine to silently ignore
|
}
|
}
|
|
return TypeData.FromType(typeof(CliActionExecutor)).Assembly.SemanticVersion.ToString(); // OpenTAP is not installed. lets just return this.
|
}
|
string tapCommand = OperatingSystem.Current == OperatingSystem.Windows ? "tap.exe" : "tap";
|
|
var helpOptions = new string[] { "--help", "-help", "-h" };
|
bool isHelp = args.Length == 0 || args.Any(a => helpOptions.Contains(a.ToLower()));
|
|
if (!isHelp)
|
{
|
log.Error($"\"{tapCommand} {string.Join(" ", args)}\" is not a recognized command.");
|
}
|
|
log.Info("OpenTAP Command Line Interface ({0})", getVersion());
|
log.Info($"Usage: \"{tapCommand} <command> [<subcommand(s)>] [<args>]\"\n");
|
|
if (selectedcmd == null)
|
{
|
log.Info("Valid commands are:");
|
foreach (var cmd in actionTree.SubCommands)
|
{
|
print_command(cmd, 0, actionTree.GetMaxCommandTreeLength(LevelPadding) + LevelPadding);
|
}
|
}
|
else
|
{
|
log.Info($"Valid subcommands of");
|
print_command(selectedcmd, 0, actionTree.GetMaxCommandTreeLength(LevelPadding) + LevelPadding);
|
}
|
|
log.Info($"\nRun \"{tapCommand} <command> [<subcommand(s)>] -h\" to get additional help for a specific command.\n");
|
|
if (isHelp)
|
return (int)ExitCodes.Success;
|
else
|
return (int)ExitCodes.ArgumentParseError;
|
}
|
|
if (SelectedAction != TypeData.FromType(typeof(RunCliAction)) && UserInput.Interface == null) // RunCliAction has --non-interactive flag and custom platform interaction handling.
|
CliUserInputInterface.Load();
|
|
ICliAction packageAction = null;
|
try
|
{
|
packageAction = (ICliAction)SelectedAction.CreateInstance();
|
}
|
catch (TargetInvocationException e1) when (e1.InnerException is System.ComponentModel.LicenseException e)
|
{
|
log.Error("Unable to load CLI Action '{0}'", SelectedAction.GetDisplayAttribute().GetFullName());
|
log.Info("{0}", e.Message);
|
return (int)ExitCodes.UnknownCliAction;
|
}
|
catch (InvalidOperationException ex)
|
{
|
log.Error("Unable to load CLI Action '{0}'", SelectedAction.GetDisplayAttribute().GetFullName());
|
log.Info("{0}", ex.Message);
|
return (int)ExitCodes.GeneralException;
|
}
|
|
if (packageAction == null)
|
{
|
Console.WriteLine("Error instantiating command {0}", SelectedAction.Name);
|
return (int)ExitCodes.UnknownCliAction;
|
}
|
|
try
|
{
|
int skip = SelectedAction.GetDisplayAttribute().Group.Length + 1; // If the selected command has a group, it takes two arguments to use the command. E.g. "package create". If not, it only takes 1 argument, E.g. "restapi".
|
return packageAction.Execute(args.Skip(skip).ToArray());
|
}
|
catch (ExitCodeException ec)
|
{
|
log.Error(ec.Message);
|
return ec.ExitCode;
|
}
|
catch(ArgumentException ae)
|
{
|
// ArgumentException usually contains several lines.
|
// Only print the first line as an error message.
|
// Example message:
|
// "Directory is not a git repository.
|
// Parameter name: repositoryDir"
|
var lines = ae.Message.Split(new char[] { '\r', '\n' },StringSplitOptions.RemoveEmptyEntries);
|
log.Error(lines.First());
|
for(int i = 1;i<lines.Length;i++)
|
log.Debug(lines[i]);
|
return (int)ExitCodes.ArgumentError;
|
}
|
catch (OperationCanceledException ex)
|
{
|
log.Error(ex.Message);
|
return (int)ExitCodes.UserCancelled;
|
}
|
catch (Exception ex)
|
{
|
Log.Flush();
|
if (ex is AggregateException aex)
|
{
|
foreach (var innerException in aex.InnerExceptions)
|
log.Error(innerException.Message);
|
}
|
|
log.Error("{0}", ex.Message);
|
log.Debug(ex);
|
return (int)ExitCodes.GeneralException;
|
}
|
finally
|
{
|
Log.Flush();
|
}
|
}
|
}
|
}
|
