private void ShowError(PSHostUserInterface hostUI) { if (_error != null) { hostUI.WriteErrorLine(_error); } }
public static void Patch(int version, EngineIntrinsics context, PSHostUserInterface ui) { Clear(); var uiFieldName = version >= 7 ? "_externalUI" : "externalUI"; // we get InternalHostUserInterface, grab external ui from that and replace it with ours var externalUIField = ui.GetType().GetField(uiFieldName, BindingFlags.Instance | BindingFlags.NonPublic); var externalUI = (PSHostUserInterface)externalUIField.GetValue(ui); // replace it with out patched up UI that writes to profiler on debug externalUIField.SetValue(ui, new ProfilerUI(externalUI)); ResetUI = () => { externalUIField.SetValue(ui, externalUI); }; // getting MethodInfo of context._context.Debugger.TraceLine var bf = BindingFlags.NonPublic | BindingFlags.Instance; var contextInternal = context.GetType().GetField("_context", bf).GetValue(context); var debugger = contextInternal.GetType().GetProperty("Debugger", bf).GetValue(contextInternal); var debuggerType = debugger.GetType(); var callStackField = debuggerType.GetField("_callStack", BindingFlags.Instance | BindingFlags.NonPublic); var _callStack = callStackField.GetValue(debugger); var callStackType = _callStack.GetType(); var countProperty = callStackType.GetProperty("Count", BindingFlags.Instance | BindingFlags.NonPublic); var getCount = countProperty.GetMethod; var empty = new object[0]; var stack = callStackField.GetValue(debugger); var initialLevel = (int)getCount.Invoke(stack, empty); var lastFunctionContextMethod = callStackType.GetMethod("LastFunctionContext", BindingFlags.Instance | BindingFlags.NonPublic); object functionContext1 = lastFunctionContextMethod.Invoke(callStackField.GetValue(debugger), empty); var functionContextType = functionContext1.GetType(); var scriptBlockField = functionContextType.GetField("_scriptBlock", BindingFlags.Instance | BindingFlags.NonPublic); var currentPositionProperty = functionContextType.GetProperty("CurrentPosition", BindingFlags.Instance | BindingFlags.NonPublic); var scriptBlock1 = (ScriptBlock)scriptBlockField.GetValue(functionContext1); var extent1 = (IScriptExtent)currentPositionProperty.GetValue(functionContext1); TraceLine = () => { var callStack = callStackField.GetValue(debugger); var level = (int)getCount.Invoke(callStack, empty) - initialLevel; object functionContext = lastFunctionContextMethod.Invoke(callStack, empty); var scriptBlock = (ScriptBlock)scriptBlockField.GetValue(functionContext); var extent = (IScriptExtent)currentPositionProperty.GetValue(functionContext); Trace(extent, scriptBlock, level); }; // Add another event to the top apart from the scriptblock invocation // in Trace-ScriptInternal, this makes it more consistently work on first // run. Without this, the triggering line sometimes does not show up as 99.9% TraceLine(); }
internal void ReportEngineStartupError(string resourceString, params object[] arguments) { try { Cmdlet cmdlet; string str; if (this.IsModuleCommandCurrentlyRunning(out cmdlet, out str)) { RuntimeException replaceParentContainsErrorRecordException = InterpreterError.NewInterpreterException(null, typeof(RuntimeException), null, str, resourceString, arguments); cmdlet.WriteError(new ErrorRecord(replaceParentContainsErrorRecordException.ErrorRecord, replaceParentContainsErrorRecordException)); } else { PSHost engineHostInterface = this.EngineHostInterface; if (engineHostInterface != null) { PSHostUserInterface uI = engineHostInterface.UI; if (uI != null) { uI.WriteErrorLine(StringUtil.Format(resourceString, arguments)); } } } } catch (Exception exception2) { CommandProcessorBase.CheckForSevereException(exception2); } }
internal void ReportEngineStartupError(Exception e) { try { Cmdlet cmdlet; string str; if (this.IsModuleCommandCurrentlyRunning(out cmdlet, out str)) { ErrorRecord errorRecord = null; RuntimeException replaceParentContainsErrorRecordException = e as RuntimeException; errorRecord = (replaceParentContainsErrorRecordException != null) ? new ErrorRecord(replaceParentContainsErrorRecordException.ErrorRecord, replaceParentContainsErrorRecordException) : new ErrorRecord(e, str, ErrorCategory.OperationStopped, null); cmdlet.WriteError(errorRecord); } else { PSHost engineHostInterface = this.EngineHostInterface; if (engineHostInterface != null) { PSHostUserInterface uI = engineHostInterface.UI; if (uI != null) { uI.WriteErrorLine(e.Message); } } } } catch (Exception exception2) { CommandProcessorBase.CheckForSevereException(exception2); } }
internal void ReportEngineStartupError(ErrorRecord errorRecord) { try { Cmdlet cmdlet; string str; if (this.IsModuleCommandCurrentlyRunning(out cmdlet, out str)) { cmdlet.WriteError(errorRecord); } else { PSHost engineHostInterface = this.EngineHostInterface; if (engineHostInterface != null) { PSHostUserInterface uI = engineHostInterface.UI; if (uI != null) { uI.WriteErrorLine(errorRecord.ToString()); } } } } catch (Exception exception) { CommandProcessorBase.CheckForSevereException(exception); } }
public void DetachFromHost() { if (host == null) { return; } const BindingFlags flags = BindingFlags.Instance | BindingFlags.NonPublic; // When PowerShell went open source, they renamed the private variables to have _underbarPrefixes if (host.Version >= new Version(6, 0)) { object uiRef = host.GetType().GetField("_internalUIRef", flags)?.GetValue(host); object ui = uiRef.GetType().GetProperty("Value", flags).GetValue(uiRef, null); FieldInfo externalUIField = ui.GetType().GetField("_externalUI", flags); if (externalUIField.GetValue(ui) == this) { externalUIField.SetValue(ui, externalUI); } } else { // Try the WindowsPowerShell version: object uiRef = host.GetType().GetField("internalUIRef", flags).GetValue(host); object ui = uiRef.GetType().GetProperty("Value", flags).GetValue(uiRef, null); FieldInfo externalUIField = ui.GetType().GetField("externalUI", flags); if (externalUIField.GetValue(ui) == this) { externalUIField.SetValue(ui, externalUI); } } externalUI = null; host = null; }
public void AttachToHost(PSHost host) { if (this.host != null) { return; } if (host == null) { return; } const BindingFlags flags = BindingFlags.Instance | BindingFlags.NonPublic; // When PowerShell went open source, they renamed the private variables to have _underbarPrefixes if (host.Version >= new Version(6, 0)) { object uiRef = host.GetType().GetField("_internalUIRef", flags)?.GetValue(host); object ui = uiRef.GetType().GetProperty("Value", flags).GetValue(uiRef, null); FieldInfo externalUIField = ui.GetType().GetField("_externalUI", flags); externalUI = (PSHostUserInterface)externalUIField.GetValue(ui); externalUIField.SetValue(ui, this); } else { // Try the WindowsPowerShell version: object uiRef = host.GetType().GetField("internalUIRef", flags).GetValue(host); object ui = uiRef.GetType().GetProperty("Value", flags).GetValue(uiRef, null); FieldInfo externalUIField = ui.GetType().GetField("externalUI", flags); externalUI = (PSHostUserInterface)externalUIField.GetValue(ui); externalUIField.SetValue(ui, this); } this.host = host; }
/// <summary> /// Creates a new instance of the ConsoleServicePSHostUserInterface /// class with the given IConsoleHost implementation. /// </summary> /// <param name="powerShellContext">The PowerShellContext to use for executing commands.</param> /// <param name="logger">An ILogger implementation to use for this host.</param> /// <param name="internalHost">The InternalHost instance from the origin runspace.</param> public TerminalPSHostUserInterface( PowerShellContextService powerShellContext, ILogger logger, PSHost internalHost) : base( powerShellContext, new TerminalPSHostRawUserInterface(logger, internalHost), logger) { this.internalHostUI = internalHost.UI; this.consoleReadLine = new ConsoleReadLine(powerShellContext); // Set the output encoding to UTF-8 so that special // characters are written to the console correctly System.Console.OutputEncoding = System.Text.Encoding.UTF8; System.Console.CancelKeyPress += (obj, args) => { if (!this.IsNativeApplicationRunning) { // We'll handle Ctrl+C args.Cancel = true; this.SendControlC(); } }; }
InternalHostUserInterface(PSHostUserInterface externalUI, InternalHost parentHost) { // externalUI may be null _externalUI = externalUI; // parent may not be null, however Dbg.Assert(parentHost != null, "parent may not be null"); if (parentHost == null) { throw PSTraceSource.NewArgumentNullException(nameof(parentHost)); } _parent = parentHost; PSHostRawUserInterface rawui = null; if (externalUI != null) { rawui = externalUI.RawUI; } _internalRawUI = new InternalHostRawUserInterface(rawui, _parent); }
internal PromptResponse PromptUser(PSHostUserInterface console) { char ch = char.MinValue; for (int i = 0; i < this.actualPrompt.Count; i++) { if (i < (this.actualPrompt.Count - 1)) { console.WriteLine(this.actualPrompt[i]); } else { console.Write(this.actualPrompt[i]); } } do { this.callingCmdlet.CheckStopProcessing(); switch (console.RawUI.ReadKey(ReadKeyOptions.IncludeKeyUp | ReadKeyOptions.NoEcho).Character) { case 'q': case 'Q': console.WriteLine(); return(PromptResponse.Quit); case ' ': console.WriteLine(); return(PromptResponse.NextPage); } }while (ch != '\r'); console.WriteLine(); return(PromptResponse.NextLine); }
/// <summary> /// Just hook up the LineOutput interface. /// </summary> protected override void BeginProcessing() { PSHostUserInterface console = this.Host.UI; ConsoleLineOutput lineOutput = new ConsoleLineOutput(console, false, new TerminatingErrorContext(this)); ((OutputManagerInner)this.implementation).LineOutput = lineOutput; MshCommandRuntime mrt = this.CommandRuntime as MshCommandRuntime; if (mrt != null) { mrt.MergeUnclaimedPreviousErrorResults = true; } if (Transcript) { _transcribeOnlyCookie = Host.UI.SetTranscribeOnly(); } // This needs to be done directly through the command runtime, as Out-Default // doesn't actually write pipeline objects. base.BeginProcessing(); if (Context.CurrentCommandProcessor.CommandRuntime.OutVarList != null) { _outVarResults = new List <PSObject>(); } }
internal static SecureString PromptForSecureString(PSHostUserInterface hostUI, string prompt) { hostUI.Write(prompt); SecureString secureString = hostUI.ReadLineAsSecureString(); hostUI.WriteLine(""); return(secureString); }
private HostIOInterceptor() { externalUI = null; subscribers = new List <WeakReference>(); writeCache = new StringBuilder(); paused = false; host = null; }
internal Host(PoshConsole control, Options options) { PoshConsole = control; _options = options; _UI = new HostUI(PoshConsole); MakeConsole(); }
/// <summary> /// Just hook up the LineOutput interface. /// </summary> protected override void BeginProcessing() { PSHostUserInterface console = this.Host.UI; ConsoleLineOutput lineOutput = new ConsoleLineOutput(console, _paging, new TerminatingErrorContext(this)); ((OutputManagerInner)this.implementation).LineOutput = lineOutput; base.BeginProcessing(); }
internal Host(PoshConsole control, Panel progress, Options options) { PoshConsole = control; _options = options; _UI = new HostUI(PoshConsole, progress); MakeConsole(); }
public PsEntrypointPSHost() { m_InstanceId = Guid.NewGuid(); m_Name = "PSDockerHost"; m_CurrentCulture = System.Threading.Thread.CurrentThread.CurrentCulture; m_CurrentUICulture = System.Threading.Thread.CurrentThread.CurrentUICulture; m_UI = new HostUI(); }
/// <summary></summary> /// <param name="ui"></param> /// <param name="activity"></param> /// <param name="text"></param> public CmdletProgress(PSHostUserInterface ui, string activity, string statusDescription) { this.sourceId = Environment.TickCount; this.ui = ui; this.progress = new ProgressRecord(Math.Abs(activity.GetHashCode()), activity, statusDescription); ui.WriteProgress(sourceId, progress); } // ctor
private string _header; // Header to print when at BOL internal TaskHostUI(PSHostUserInterface ui, ConsoleState console, int taskId) { _ui = ui ?? throw new ArgumentNullException(nameof(ui)); _console = console ?? throw new ArgumentNullException(nameof(console)); _taskId = taskId; _taskBol = true; _header = $"Task {taskId}"; }
public AEMHelper(Action <ErrorRecord> errorAction, Action <string> verboseAction, Action <string> warningAction, PSHostUserInterface ui, StorageManagementClient storageClient, AzureSubscription subscription) { this._ErrorAction = errorAction; this._VerboseAction = verboseAction; this._WarningAction = warningAction; this._UI = ui; this._StorageClient = storageClient; this._Subscription = subscription; }
internal InternalHost(PSHost externalHost, ExecutionContext executionContext) { this.externalHostRef = new ObjectRef <PSHost>(externalHost); this.executionContext = executionContext; PSHostUserInterface uI = externalHost.UI; this.internalUIRef = new ObjectRef <InternalHostUserInterface>(new InternalHostUserInterface(uI, this)); this.zeroGuid = new Guid(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0); this.idResult = this.zeroGuid; }
public Host(string name, Version version, PSHostUserInterface hostUI, RunspaceConfiguration runspaceConfiguration) { _pushedRunspaces = new Stack <Runspace>(); _name = name; _version = version; _hostUI = hostUI; _runspaceConfiguration = runspaceConfiguration; _exitEvent = new ManualResetEvent(false); }
/// <summary> /// present a prompt for a SecureString data /// </summary> /// /// <param name="hostUI"> ref to host ui interface </param> /// /// <param name="prompt"> prompt text </param> /// /// <returns> user input as secure string </returns> /// /// <remarks> </remarks> /// internal static SecureString PromptForSecureString(PSHostUserInterface hostUI, string prompt) { SecureString ss = null; hostUI.Write(prompt); ss = hostUI.ReadLineAsSecureString(); hostUI.WriteLine(string.Empty); return(ss); }
internal CommandLineParameterParser(PSHostUserInterface hostUI, string bannerText, string helpText) { if (hostUI == null) { throw new PSArgumentNullException("hostUI"); } _hostUI = hostUI; _bannerText = bannerText; _helpText = helpText; }
public ScriptHost(IUpgradeLog logger) { _hostUI = new ScriptHostUI(logger); _id = Guid.NewGuid(); _originalCultureInfo = Thread.CurrentThread.CurrentCulture; _originalUICultureInfo = Thread.CurrentThread.CurrentUICulture; var assembly = System.Reflection.Assembly.GetExecutingAssembly(); var fvi = FileVersionInfo.GetVersionInfo(assembly.Location); _version = new Version(fvi.FileMajorPart, fvi.FileMinorPart, fvi.FileBuildPart, fvi.FilePrivatePart); }
// Maybe we shouldn't do update check and show notification when it's from a mini-shell, meaning when // 'ConsoleShell.Start' is not called by 'ManagedEntrance.Start'. // But it seems so unusual that it's probably not worth bothering. Also, a mini-shell probably should // just disable the update notification feature by setting the opt-out environment variable. internal static void ShowUpdateNotification(PSHostUserInterface hostUI) { if (!Directory.Exists(s_cacheDirectory)) { return; } if (TryParseUpdateFile( updateFilePath: out _, out SemanticVersion lastUpdateVersion, lastUpdateDate: out _) && lastUpdateVersion != null) { string releaseTag = lastUpdateVersion.ToString(); string notificationMsgTemplate = s_notificationType == NotificationType.LTS ? ManagedEntranceStrings.LTSUpdateNotificationMessage : string.IsNullOrEmpty(lastUpdateVersion.PreReleaseLabel) ? ManagedEntranceStrings.StableUpdateNotificationMessage : ManagedEntranceStrings.PreviewUpdateNotificationMessage; string notificationColor = string.Empty; string resetColor = string.Empty; string line2Padding = string.Empty; string line3Padding = string.Empty; // We calculate how much whitespace we need to make it look nice if (hostUI.SupportsVirtualTerminal) { // Swaps foreground and background colors. notificationColor = "\x1B[7m"; resetColor = "\x1B[0m"; // The first line is longest, if the message changes, this needs to be updated int line1Length = notificationMsgTemplate.IndexOf('\n'); int line2Length = notificationMsgTemplate.IndexOf('\n', line1Length + 1); int line3Length = notificationMsgTemplate.IndexOf('\n', line2Length + 1); line3Length -= line2Length + 1; line2Length -= line1Length + 1; line2Padding = line2Padding.PadRight(line1Length - line2Length + releaseTag.Length); // 3 represents the extra placeholder in the template line3Padding = line3Padding.PadRight(line1Length - line3Length + 3); } string notificationMsg = string.Format(CultureInfo.CurrentCulture, notificationMsgTemplate, releaseTag, notificationColor, resetColor, line2Padding, line3Padding); hostUI.WriteLine(); hostUI.WriteLine(notificationMsg); } }
/// <summary> /// constructor for the ConsoleLineOutput /// </summary> /// <param name="hostConsole">PSHostUserInterface to wrap</param> /// <param name="paging">true if we require prompting for page breaks</param> /// <param name="errorContext">error context to throw exceptions</param> internal ConsoleLineOutput(PSHostUserInterface hostConsole, bool paging, TerminatingErrorContext errorContext) { if (hostConsole == null) { throw PSTraceSource.NewArgumentNullException("hostConsole"); } if (errorContext == null) { throw PSTraceSource.NewArgumentNullException("errorContext"); } _console = hostConsole; _errorContext = errorContext; if (paging) { tracer.WriteLine("paging is needed"); // if we need to do paging, instantiate a prompt handler // that will take care of the screen interaction string promptString = StringUtil.Format(FormatAndOut_out_xxx.ConsoleLineOutput_PagingPrompt); _prompt = new PromptHandler(promptString, this); } PSHostRawUserInterface raw = _console.RawUI; if (raw != null) { tracer.WriteLine("there is a valid raw interface"); #if TEST_MULTICELL_ON_SINGLE_CELL_LOCALE // create a test instance with fake behavior this._displayCellsPSHost = new DisplayCellsTest(); #else // set only if we have a valid raw interface _displayCellsPSHost = new DisplayCellsPSHost(raw); #endif } // instantiate the helper to do the line processing when ILineOutput.WriteXXX() is called WriteLineHelper.WriteCallback wl = new WriteLineHelper.WriteCallback(this.OnWriteLine); WriteLineHelper.WriteCallback w = new WriteLineHelper.WriteCallback(this.OnWrite); if (_forceNewLine) { _writeLineHelper = new WriteLineHelper(/*lineWrap*/ false, wl, null, this.DisplayCells); } else { _writeLineHelper = new WriteLineHelper(/*lineWrap*/ false, wl, w, this.DisplayCells); } }
public Host(WpfTerminalControl uicontrol) { if (uicontrol == null) { throw new ArgumentNullException(nameof(uicontrol)); } this.InstanceId = Guid.NewGuid(); this.HostUI = new HostUI(uicontrol); _uI = this.HostUI; this.Name = "Host1"; this.Version = Version.Parse("0.1"); _CurrentCulture = System.Threading.Thread.CurrentThread.CurrentCulture ?? System.Threading.Thread.CurrentThread.CurrentUICulture ?? CultureInfo.InstalledUICulture; _CurrentUICulture = _CurrentCulture; }
/// <summary> /// Write a line by delegating to the writer underneath. /// </summary> /// <param name="s"></param> internal override void WriteLine(string s) { CheckStopProcessing(); s = PSHostUserInterface.GetOutputString(s, isHost: false); if (_suppressNewline) { _writer.Write(s); } else { _writer.WriteLine(s); } }
public Poco() { var runspace = Runspace.DefaultRunspace; Pipeline pipeline = runspace.CreateNestedPipeline("Get-Variable host -ValueOnly", false); Collection <PSObject> results = pipeline.Invoke(); if (results.Count > 0) { var host = results[0].BaseObject as PSHost; if (host != null) { _ui = host.UI; } } }
public PSHost(PSHostUserInterface hostUserInterface) { this.hostUserInterface = hostUserInterface; }