// 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.Concurrent;
|
using System.Collections.Generic;
|
using System.Linq;
|
using System.Security;
|
using System.Text;
|
using System.Threading;
|
using OpenTap.Translation;
|
|
namespace OpenTap
|
{
|
/// <summary>
|
/// Class for getting user input without using GUI.
|
/// </summary>
|
public class UserInput
|
{
|
/// <summary> Request user input from the GUI. Waits an amount of time specified by Timeout. If the timeout occurs a TimeoutException will be thrown.</summary>
|
/// <param name="dataObject">The object the user should fill out with data.</param>
|
/// <param name="Timeout">How long to wait before timing out. </param>
|
/// <param name="modal">set to True if a modal request is wanted. This means the user will have to answer before doing anything else.</param>
|
public static void Request(object dataObject, TimeSpan Timeout, bool modal = false)
|
{
|
inputInterface?.RequestUserInput(dataObject, Timeout, modal);
|
}
|
|
/// <summary> Request user input from the GUI. Waits indefinitely.</summary>
|
/// <param name="dataObject">The object the user should fill out with data.</param>
|
/// <param name="modal">set to True if a modal request is wanted. This means the user will have to answer before doing anything else.</param>
|
public static void Request(object dataObject, bool modal = false)
|
{
|
inputInterface?.RequestUserInput(dataObject, TimeSpan.MaxValue, modal);
|
}
|
|
/// <summary> Currently selected interface. </summary>
|
public static object Interface => inputInterface;
|
|
static readonly SessionLocal<IUserInputInterface> _inputInterface = new SessionLocal<IUserInputInterface>(false);
|
static IUserInputInterface inputInterface => _inputInterface.Value;
|
static IUserInterface userInterface => inputInterface as IUserInterface;
|
/// <summary> Sets the current user input interface. This should almost never be called from user code. </summary>
|
/// <param name="inputInterface"></param>
|
public static void SetInterface(IUserInputInterface inputInterface)
|
{
|
_inputInterface.Value = inputInterface;
|
}
|
|
/// <summary> Call to notify the user interface that an object property has changed. </summary>
|
/// <param name="obj"></param>
|
/// <param name="property"></param>
|
public static void NotifyChanged(object obj, string property)
|
{
|
userInterface?.NotifyChanged(obj, property);
|
}
|
|
/// <summary> Gets the current user input interface. </summary>
|
/// <returns></returns>
|
public static IUserInputInterface GetInterface() => inputInterface;
|
}
|
|
/// <summary> Defines a way for plugins to notify the user that a property has changed. </summary>
|
public interface IUserInterface
|
{
|
/// <summary>
|
/// This method is called to notify that a property has changed on an object.
|
/// </summary>
|
/// <param name="obj"></param>
|
/// <param name="property"></param>
|
void NotifyChanged(object obj, string property);
|
}
|
|
/// <summary> Defines a way for plugins to request input from the user. </summary>
|
public interface IUserInputInterface
|
{
|
/// <summary> The method called when the interface requests user input.</summary>
|
/// <param name="dataObject">The object the user should fill out with data.</param>
|
/// <param name="Timeout">How long the user should have.</param>
|
/// <param name="modal"> True if a modal request is wanted</param>
|
void RequestUserInput(object dataObject, TimeSpan Timeout, bool modal);
|
}
|
|
/// <summary> The supported layout modes. </summary>
|
[Flags]
|
public enum LayoutMode
|
{
|
/// <summary> The default mode.</summary>
|
Normal = 1,
|
/// <summary> The user input fills the whole row. </summary>
|
FullRow = 2,
|
/// <summary> The user input floats to the bottom.</summary>
|
FloatBottom = 4,
|
///<summary> Whether text wrapping should be enabled. </summary>
|
WrapText = 8
|
}
|
|
/// <summary> LayoutAttribute can be used to specify the wanted layout for user interfaces.</summary>
|
public class LayoutAttribute : Attribute
|
{
|
/// <summary> Specifies the mode of layout.</summary>
|
public LayoutMode Mode { get; }
|
|
/// <summary> How much height should the input take. </summary>
|
public int RowHeight { get; }
|
|
/// <summary> Maximum row height for the input. </summary>
|
public int MaxRowHeight { get; } = 1000;
|
|
/// <summary> Minimum width. The unit is the width of an average character. Not an exact number of pixels.
|
/// This can be used for displaying where the width is a variable, and it's useful with a first guess.</summary>
|
public int MinWidth { get; set; } = -1;
|
|
/// <summary> Creates a new instance of layout attribute. </summary>
|
public LayoutAttribute(LayoutMode mode, int rowHeight = 1, int maxRowHeight = 1000)
|
{
|
Mode = mode;
|
RowHeight = rowHeight;
|
MaxRowHeight = maxRowHeight;
|
}
|
|
/// <summary> Creates a new instance of layout attribute. </summary>
|
public LayoutAttribute() : this(0)
|
{
|
|
}
|
}
|
|
/// <summary> Specifies that a property finalizes input.</summary>
|
public class SubmitAttribute : Attribute { }
|
|
/// <summary> Standard implementation of UserInputInterface for Command Line interfaces</summary>
|
public class CliUserInputInterface : IUserInputInterface
|
{
|
class Strings : IStringLocalizer
|
{
|
public static readonly Strings strings = new();
|
public static string PleaseEnterNumberOrName => strings.Translate("Please enter a number or name ");
|
public static string PleaseEnter => strings.Translate("Please enter ");
|
public static string Default => strings.Translate(" (default)");
|
}
|
|
/// <summary>
|
/// Thrown when userinput is requested when reading input from stdin and EOF is reached
|
/// </summary>
|
internal class EOFException : Exception
|
{
|
/// <summary>
|
/// Initializes a new instance of the <see cref="EOFException"/> class with the specified message.
|
/// </summary>
|
/// <param name="message"></param>
|
public EOFException(string message) : base(message)
|
{
|
}
|
}
|
|
private bool IsPipeInput { get; }
|
|
/// <summary>
|
/// Initializes a new instance of the <see cref="CliUserInputInterface"/> class in interactive mode.
|
/// </summary>
|
public CliUserInputInterface()
|
{
|
IsPipeInput = Console.IsInputRedirected;
|
}
|
|
readonly Mutex userInputMutex = new Mutex();
|
readonly object readerLock = new object();
|
|
private TapThread StartKeyboardReader()
|
{
|
return TapThread.Start(() =>
|
{
|
try
|
{
|
var sb = new StringBuilder();
|
|
while (true)
|
{
|
var chr = Console.ReadKey(true);
|
if (chr.KeyChar == 0)
|
continue;
|
if (chr.Key != ConsoleKey.Enter && chr.Key != ConsoleKey.Backspace)
|
Console.Write(IsSecure ? '*' : chr.KeyChar);
|
|
if (chr.Key == ConsoleKey.Enter)
|
{
|
lines.Add(sb.ToString());
|
sb.Clear();
|
Console.WriteLine();
|
}
|
|
if (chr.Key == ConsoleKey.Backspace)
|
{
|
if (sb.Length > 0)
|
{
|
sb.Remove(sb.Length - 1, 1);
|
// delete current char and move back.
|
Console.Write("\b \b");
|
}
|
}
|
else
|
{
|
sb.Append(chr.KeyChar);
|
}
|
}
|
}
|
catch (Exception e)
|
{
|
log.Error(e);
|
}
|
}, "Console Reader");
|
}
|
|
private bool EOFReached = false;
|
|
private TapThread StartPipeReader()
|
{
|
return TapThread.Start(() =>
|
{
|
const int EOF = -1;
|
int b;
|
var buf = new List<byte>();
|
var stdin = Console.OpenStandardInput();
|
do
|
{
|
b = stdin.ReadByte();
|
switch (b)
|
{
|
// If the line was terminaed, add the buffer to the list of lines, and clear the buffer.
|
case '\n':
|
case EOF:
|
lines.Add(Encoding.UTF8.GetString(buf.ToArray()));
|
buf.Clear();
|
break;
|
// Otherwise, add the char we just read to the buffer
|
default:
|
buf.Add((byte)b);
|
break;
|
}
|
} while (b != EOF);
|
EOFReached = true;
|
}, "Pipe Reader");
|
}
|
|
private void MaybeStartReader()
|
{
|
if (readerThread == null)
|
lock (readerLock)
|
if (readerThread == null)
|
{
|
readerThread = IsPipeInput ? StartPipeReader() : StartKeyboardReader();
|
}
|
}
|
|
void IUserInputInterface.RequestUserInput(object dataObject, TimeSpan timeout, bool modal)
|
{
|
// If we are running in pipe mode, and EOF was reached, error or return immediately
|
if (EOFReached && IsPipeInput)
|
{
|
throw new EOFException("End of input stream reached.");
|
}
|
|
MaybeStartReader();
|
|
DateTime timeoutAt;
|
if (timeout == TimeSpan.MaxValue)
|
timeoutAt = DateTime.MaxValue;
|
else
|
timeoutAt = DateTime.Now + timeout;
|
|
if (timeout >= new TimeSpan(0, 0, 0, 0, int.MaxValue))
|
timeout = new TimeSpan(0, 0, 0, 0, -1);
|
do
|
{
|
if (userInputMutex.WaitOne(timeout))
|
break;
|
if (DateTime.Now >= timeoutAt)
|
throw new TimeoutException("Request User Input timed out");
|
} while (true);
|
|
try
|
{
|
var a = AnnotationCollection.Annotate(dataObject);
|
|
AnnotationCollection[] members;
|
{
|
var members2 = a.Get<IMembersAnnotation>()?.Members;
|
|
if (members2 == null) return;
|
members2 = members2.Concat(a.Get<IForwardedAnnotations>()?.Forwarded ?? Array.Empty<AnnotationCollection>());
|
|
// Order members
|
members2 = members2.OrderBy(m => m.Get<DisplayAttribute>()?.Name ?? m.Get<IMemberAnnotation>()?.Member.Name);
|
members2 = members2.OrderBy(m => m.Get<DisplayAttribute>()?.Order ?? -10000);
|
members2 = members2.OrderBy(m => m.Get<IMemberAnnotation>()?.Member?.GetAttribute<LayoutAttribute>()?.Mode == LayoutMode.FloatBottom ? 1 : 0);
|
members2 = members2.OrderBy(m => m.Get<IMemberAnnotation>()?.Member?.HasAttribute<SubmitAttribute>() == true ? 1 : 0);
|
members = members2.ToArray();
|
}
|
|
var display = a.Get<IDisplayAnnotation>();
|
|
string title = null;
|
if (display is DisplayAttribute attr && attr.IsDefaultAttribute() == false)
|
title = display.Name;
|
|
// flush and make sure that there is no new log messages coming in before starting to message the user.
|
Log.Flush();
|
if (string.IsNullOrWhiteSpace(title))
|
// fallback magic
|
title = TypeData.GetTypeData(dataObject)?.GetMember("Name")?.GetValue(dataObject) as string;
|
if (string.IsNullOrWhiteSpace(title) == false)
|
{
|
Console.WriteLine(title);
|
}
|
bool isBrowsable(IMemberData m)
|
{
|
var browsable = m.GetAttribute<System.ComponentModel.BrowsableAttribute>();
|
|
// Browsable overrides everything
|
if (browsable != null) return browsable.Browsable;
|
|
if (m is IMemberData mem)
|
{
|
if (m.HasAttribute<OutputAttribute>())
|
return true;
|
if (!mem.Writable || !mem.Readable)
|
return false;
|
return true;
|
}
|
return false;
|
}
|
|
// indent readonly items to the same level
|
int readonlyIndent = 0;
|
foreach (var _message in members)
|
{
|
var layout = _message.Get<IMemberAnnotation>()?.Member.GetAttribute<LayoutAttribute>();
|
bool showName = layout?.Mode.HasFlag(LayoutMode.FullRow) == true ? false : true;
|
var isReadOnly = _message.Get<IAccessAnnotation>()?.IsReadOnly ?? false;
|
if (showName && isReadOnly)
|
{
|
var name = _message.Get<DisplayAttribute>()?.Name ?? "";
|
readonlyIndent = Math.Max(name.Length, readonlyIndent);
|
}
|
}
|
|
foreach (var _message in members)
|
{
|
var mem = _message.Get<IMemberAnnotation>()?.Member;
|
if (mem != null)
|
{
|
if (!isBrowsable(mem)) continue;
|
}
|
|
bool secure = _message.Get<IReflectionAnnotation>()?.ReflectionInfo.DescendsTo(typeof(SecureString)) ?? false;
|
var str = _message.Get<IStringValueAnnotation>();
|
if (str == null && !secure) continue;
|
var name = _message.Get<DisplayAttribute>()?.Name ?? "";
|
|
start:
|
var isVisible = _message.Get<IAccessAnnotation>()?.IsVisible ?? true;
|
if (!isVisible) continue;
|
|
var layout = _message.Get<IMemberAnnotation>()?.Member.GetAttribute<LayoutAttribute>();
|
bool showName = layout?.Mode.HasFlag(LayoutMode.FullRow) == true ? false : true;
|
|
var isReadOnly = _message.Get<IAccessAnnotation>()?.IsReadOnly ?? false;
|
if (isReadOnly)
|
{
|
if (showName)
|
{
|
// Indent
|
// Each text line should be indented separately
|
var text = str.Value;
|
var textLines = text.Replace("\r", "").Split(['\n'], StringSplitOptions.RemoveEmptyEntries);
|
var padString = "\n" + new string(' ', readonlyIndent + ": ".Length);
|
text = string.Join(padString, textLines);
|
Console.WriteLine(name.PadRight(readonlyIndent) + ": " + text);
|
}
|
else
|
{
|
Console.WriteLine($"{str.Value}");
|
}
|
|
continue;
|
}
|
|
var proxy = _message.Get<IAvailableValuesAnnotationProxy>();
|
List<string> options = null;
|
bool pleaseEnter = true;
|
if (proxy != null)
|
{
|
pleaseEnter = false;
|
options = new List<string>();
|
|
int index = 0;
|
var current_value = proxy.SelectedValue;
|
foreach (var value in proxy.AvailableValues)
|
{
|
var v = value.Get<IStringValueAnnotation>();
|
if (v != null)
|
{
|
|
Console.Write("{1}: '{0}'", v.Value, index);
|
if (value == current_value)
|
{
|
Console.WriteLine(Strings.Default);
|
}
|
else
|
{
|
Console.WriteLine();
|
}
|
}
|
options.Add(v?.Value);
|
index++;
|
}
|
Console.Write(Strings.PleaseEnterNumberOrName);
|
}
|
|
if (pleaseEnter)
|
{
|
Console.Write(Strings.PleaseEnter);
|
}
|
|
if (secure && showName)
|
{
|
Console.Write($"{name}: ");
|
}
|
else if (showName)
|
if (string.IsNullOrEmpty(str.Value))
|
Console.Write($"{name}: ");
|
else
|
Console.Write($"{name} ({str.Value}): ");
|
else if (string.IsNullOrEmpty(str.Value) == false)
|
Console.Write($"({str.Value}): ");
|
else Console.WriteLine(":");
|
|
if (secure)
|
{
|
var read2 = (awaitReadLine(timeoutAt, true)).Trim();
|
_message.Get<IObjectValueAnnotation>().Value = read2.ToSecureString();
|
continue;
|
|
}
|
|
var read = (awaitReadLine(timeoutAt, false)).Trim();
|
if (read == "")
|
{
|
// accept the default value.
|
continue;
|
}
|
try
|
{
|
|
if (options != null && int.TryParse(read, out int result))
|
{
|
if (result < options.Count)
|
read = options[result];
|
else goto start;
|
}
|
str.Value = read;
|
|
var err = a.Get<IErrorAnnotation>();
|
IEnumerable<string> errors = err?.Errors;
|
|
_message.Write();
|
if (errors?.Any() == true)
|
{
|
Console.WriteLine("Unable to parse value {0}", read);
|
goto start;
|
}
|
|
}
|
catch (Exception)
|
{
|
Console.WriteLine("Unable to parse '{0}'", read);
|
goto start;
|
}
|
}
|
a.Write();
|
}
|
finally
|
{
|
userInputMutex.ReleaseMutex();
|
}
|
}
|
|
private bool IsSecure;
|
|
/// <summary>
|
/// AwaitReadline reads the line asynchronously.
|
/// This has to be done in a thread, otherwise we cannot abort the test plan in the meantime. </summary>
|
/// <param name="timeOut"></param>
|
/// <param name="secure"></param>
|
/// <returns></returns>
|
string awaitReadLine(DateTime timeOut, bool secure)
|
{
|
try
|
{
|
IsSecure = secure;
|
while (DateTime.Now <= timeOut)
|
{
|
if (lines.TryTake(out string line, 20, TapThread.Current.AbortToken))
|
{
|
if (IsPipeInput && line == null)
|
{
|
EOFReached = true;
|
// Write an empty line to avoid the exception message appearing as the answer to the prompt
|
Console.WriteLine();
|
throw new EOFException("End of input stream reached.");
|
}
|
|
// Echo the output to stdout to indicate which option was picked from the pipe.
|
// Otherwise the stdout of the dialogue becomes confusing
|
if (IsPipeInput && secure == false && !string.IsNullOrWhiteSpace(line))
|
Console.WriteLine($"<<< '{line}'");
|
|
return line ?? "";
|
}
|
}
|
|
Console.WriteLine();
|
log.Info("Timed out while waiting for user input.");
|
throw new TimeoutException("Request user input timed out");
|
}
|
finally
|
{
|
IsSecure = false;
|
}
|
}
|
|
TapThread readerThread = null;
|
|
// Set a capacity on the blocking collection
|
private BlockingCollection<string> lines = new BlockingCollection<string>(1);
|
|
static readonly SessionLocal<bool> isLoaded = new SessionLocal<bool>();
|
|
/// <summary> Loads the CLI user input interface. Note, once it is loaded it cannot be unloaded. </summary>
|
public static void Load()
|
{
|
if (!isLoaded.Value)
|
{
|
isLoaded.Value = true;
|
UserInput.SetInterface(new CliUserInputInterface());
|
}
|
}
|
|
static readonly TraceSource log = Log.CreateSource("UserInput");
|
|
/// <summary>
|
/// Acquires a lock on the user input requests, so that user inputs will have to
|
/// wait for this object to be disposed in order to do the request.
|
/// </summary>
|
/// <returns>A disposable that must be disposed in the same thread as the caller.</returns>
|
public static IDisposable AcquireUserInputLock()
|
{
|
if (isLoaded.Value && UserInput.Interface is CliUserInputInterface cli)
|
{
|
cli.userInputMutex.WaitOne();
|
return Utils.WithDisposable(cli.userInputMutex.ReleaseMutex);
|
}
|
|
// when CliUserInputInterface is not being used we don't have to do this.
|
return Utils.WithDisposable(Utils.Noop);
|
}
|
}
|
}
|
