protected override void ProcessRecord()
{
if (this._inputObject != AutomationNull.Value)
{
if (this.script != null)
{
object[] input = new object[] { this._inputObject };
object obj2 = this.script.DoInvokeReturnAsIs(false, ScriptBlock.ErrorHandlingBehavior.WriteToCurrentErrorPipe, this.InputObject, input, AutomationNull.Value, new object[0]);
if (this.toBoolSite.Target(this.toBoolSite, obj2))
{
base.WriteObject(this.InputObject);
}
}
else
{
if (this._valueNotSpecified && ((this._binaryOperator != TokenKind.Ieq) || !this._forceBooleanEvaluation))
{
base.ThrowTerminatingError(ForEachObjectCommand.GenerateNameParameterError("Value", InternalCommandStrings.ValueNotSpecifiedForWhereObject, "ValueNotSpecifiedForWhereObject", null, new object[0]));
}
if ((!this._valueNotSpecified && (this._binaryOperator == TokenKind.Ieq)) && this._forceBooleanEvaluation)
{
base.ThrowTerminatingError(ForEachObjectCommand.GenerateNameParameterError("Operator", InternalCommandStrings.OperatorNotSpecified, "OperatorNotSpecified", null, new object[0]));
}
bool error = false;
object obj3 = this.GetValue(ref error);
if (!error)
{
try
{
if ((this._binaryOperator == TokenKind.Is) || (this._binaryOperator == TokenKind.IsNot))
{
string str = this._value as string;
if (((str != null) && str.StartsWith("[", StringComparison.CurrentCulture)) && str.EndsWith("]", StringComparison.CurrentCulture))
{
this._value = str.Substring(1, str.Length - 2);
}
}
object obj4 = this.operationDelegate(obj3, this._value);
if (this.toBoolSite.Target(this.toBoolSite, obj4))
{
base.WriteObject(this.InputObject);
}
}
catch (PipelineStoppedException)
{
throw;
}
catch (ArgumentException exception)
{
ErrorRecord errorRecord = new ErrorRecord(PSTraceSource.NewArgumentException("BinaryOperator", "ParserStrings", "BadOperatorArgument", new object[] { this._binaryOperator, exception.Message }), "BadOperatorArgument", ErrorCategory.InvalidArgument, this._inputObject);
base.WriteError(errorRecord);
}
catch (Exception exception2)
{
CommandProcessorBase.CheckForSevereException(exception2);
ErrorRecord record2 = new ErrorRecord(PSTraceSource.NewInvalidOperationException("ParserStrings", "OperatorFailed", new object[] { this._binaryOperator, exception2.Message }), "OperatorFailed", ErrorCategory.InvalidOperation, this._inputObject);
base.WriteError(record2);
}
}
}
}
}
public object VisitContinueStatement(ContinueStatementAst continueStatementAst)
{
throw PSTraceSource.NewArgumentException(nameof(continueStatementAst));
}
public object VisitExitStatement(ExitStatementAst exitStatementAst)
{
throw PSTraceSource.NewArgumentException(nameof(exitStatementAst));
}
public object VisitForStatement(ForStatementAst forStatementAst)
{
throw PSTraceSource.NewArgumentException(nameof(forStatementAst));
}
public object VisitCatchClause(CatchClauseAst catchClauseAst)
{
throw PSTraceSource.NewArgumentException(nameof(catchClauseAst));
}
public object VisitFunctionDefinition(FunctionDefinitionAst functionDefinitionAst)
{
throw PSTraceSource.NewArgumentException(nameof(functionDefinitionAst));
}
public object VisitSwitchStatement(SwitchStatementAst switchStatementAst)
{
throw PSTraceSource.NewArgumentException(nameof(switchStatementAst));
}
/// <summary>
/// Internal proxy for EnterNestedPrompt.
/// </summary>
/// <param name="callingCommand"></param>
internal void EnterNestedPrompt(InternalCommand callingCommand)
{
// Ensure we are in control of the pipeline
LocalRunspace localRunspace = null;
// This needs to be in a try / catch, since the LocalRunspace cast
// tries to verify that the host supports interactive sessions.
// Tests hosts do not.
try { localRunspace = this.Runspace as LocalRunspace; }
catch (PSNotImplementedException) { }
if (localRunspace != null)
{
Pipeline currentlyRunningPipeline = this.Runspace.GetCurrentlyRunningPipeline();
if ((currentlyRunningPipeline != null) &&
(currentlyRunningPipeline == localRunspace.PulsePipeline))
{
throw new InvalidOperationException();
}
}
// NTRAID#Windows OS Bugs-986407-2004/07/29 When kumarp has done the configuration work in the engine, it
// should include setting a bit that indicates that the initialization is complete, and code should be
// added here to throw an exception if this function is called before that bit is set.
if (NestedPromptCount < 0)
{
Dbg.Assert(false, "nested prompt counter should never be negative.");
throw PSTraceSource.NewInvalidOperationException(
InternalHostStrings.EnterExitNestedPromptOutOfSync);
}
// Increment our nesting counter. When we set the value of the variable, we will replace any existing variable
// of the same name. This is good, as any existing value is either 1) ours, and we have claim to replace it, or
// 2) is a squatter, and we have claim to clobber it.
++NestedPromptCount;
Context.SetVariable(SpecialVariables.NestedPromptCounterVarPath, NestedPromptCount);
// On entering a subshell, save and reset values of certain bits of session state
PromptContextData contextData = new PromptContextData();
contextData.SavedContextData = Context.SaveContextData();
contextData.SavedCurrentlyExecutingCommandVarValue = Context.GetVariableValue(SpecialVariables.CurrentlyExecutingCommandVarPath);
contextData.SavedPSBoundParametersVarValue = Context.GetVariableValue(SpecialVariables.PSBoundParametersVarPath);
contextData.RunspaceAvailability = this.Context.CurrentRunspace.RunspaceAvailability;
contextData.LanguageMode = Context.LanguageMode;
PSPropertyInfo commandInfoProperty = null;
PSPropertyInfo stackTraceProperty = null;
object oldCommandInfo = null;
object oldStackTrace = null;
if (callingCommand != null)
{
Dbg.Assert(callingCommand.Context == Context, "I expect that the contexts should match");
// Populate $CurrentlyExecutingCommand to facilitate debugging. One of the gotchas is that we are going to want
// to expose more and more debug info. We could just populate more and more local variables but that is probably
// a lousy approach as it pollutes the namespace. A better way to do it is to add NOTES to the variable value
// object.
PSObject newValue = PSObject.AsPSObject(callingCommand);
commandInfoProperty = newValue.Properties["CommandInfo"];
if (commandInfoProperty is null)
{
newValue.Properties.Add(new PSNoteProperty("CommandInfo", callingCommand.CommandInfo));
}
else
{
oldCommandInfo = commandInfoProperty.Value;
commandInfoProperty.Value = callingCommand.CommandInfo;
}
stackTraceProperty = newValue.Properties["StackTrace"];
if (stackTraceProperty is null)
{
newValue.Properties.Add(new PSNoteProperty("StackTrace", new System.Diagnostics.StackTrace()));
}
else
{
oldStackTrace = stackTraceProperty.Value;
stackTraceProperty.Value = new System.Diagnostics.StackTrace();
}
Context.SetVariable(SpecialVariables.CurrentlyExecutingCommandVarPath, newValue);
}
_contextStack.Push(contextData);
Dbg.Assert(_contextStack.Count == NestedPromptCount, "number of saved contexts should equal nesting count");
Context.PSDebugTraceStep = false;
Context.PSDebugTraceLevel = 0;
Context.ResetShellFunctionErrorOutputPipe();
// Lock down the language in the nested prompt
if (Context.HasRunspaceEverUsedConstrainedLanguageMode)
{
Context.LanguageMode = PSLanguageMode.ConstrainedLanguage;
}
this.Context.CurrentRunspace.UpdateRunspaceAvailability(RunspaceAvailability.AvailableForNestedCommand, true);
try
{
_externalHostRef.Value.EnterNestedPrompt();
}
catch
{
// So where things really go south is this path; which is possible for hosts (like our ConsoleHost)
// that don't return from EnterNestedPrompt immediately.
// EnterNestedPrompt() starts
// ExitNestedPrompt() called
// EnterNestedPrompt throws
ExitNestedPromptHelper();
throw;
}
finally
{
if (commandInfoProperty != null)
{
commandInfoProperty.Value = oldCommandInfo;
}
if (stackTraceProperty != null)
{
stackTraceProperty.Value = oldStackTrace;
}
}
Dbg.Assert(NestedPromptCount >= 0, "nestedPromptCounter should be greater than or equal to 0");
}
/// <summary>
/// Handler to be used in cases, where setting the state is the
/// only task being performed. This method also asserts
/// if the specified event is valid for the current state of
/// the state machine
/// </summary>
/// <param name="sender">sender of this event</param>
/// <param name="eventArgs">event args</param>
private void SetStateHandler(object sender, RemoteSessionStateMachineEventArgs eventArgs)
{
switch (eventArgs.StateEvent)
{
case RemoteSessionEvent.NegotiationCompleted:
{
Dbg.Assert(_state == RemoteSessionState.NegotiationReceived,
"State can be set to Established only when current state is NegotiationReceived");
SetState(RemoteSessionState.Established, null);
}
break;
case RemoteSessionEvent.NegotiationReceived:
{
Dbg.Assert(eventArgs.RemoteSessionCapability != null,
"State can be set to NegotiationReceived only when RemoteSessionCapability is not null");
if (eventArgs.RemoteSessionCapability == null)
{
throw PSTraceSource.NewArgumentException("eventArgs");
}
SetState(RemoteSessionState.NegotiationReceived, null);
}
break;
case RemoteSessionEvent.NegotiationSendCompleted:
{
Dbg.Assert((_state == RemoteSessionState.NegotiationSending) || (_state == RemoteSessionState.NegotiationSendingOnConnect),
"Negotiating send can be completed only when current state is NegotiationSending");
SetState(RemoteSessionState.NegotiationSent, null);
}
break;
case RemoteSessionEvent.ConnectFailed:
{
Dbg.Assert(_state == RemoteSessionState.Connecting,
"A ConnectFailed event can be raised only when the current state is Connecting");
SetState(RemoteSessionState.ClosingConnection, eventArgs.Reason);
}
break;
case RemoteSessionEvent.CloseFailed:
{
SetState(RemoteSessionState.Closed, eventArgs.Reason);
}
break;
case RemoteSessionEvent.CloseCompleted:
{
SetState(RemoteSessionState.Closed, eventArgs.Reason);
}
break;
case RemoteSessionEvent.KeyRequested:
{
Dbg.Assert(_state == RemoteSessionState.Established,
"Server can request a key only after the client reaches the Established state");
if (_state == RemoteSessionState.Established)
{
SetState(RemoteSessionState.EstablishedAndKeyRequested, eventArgs.Reason);
}
}
break;
case RemoteSessionEvent.KeyReceived:
{
Dbg.Assert(_state == RemoteSessionState.EstablishedAndKeySent,
"Key Receiving can only be raised after reaching the Established state");
if (_state == RemoteSessionState.EstablishedAndKeySent)
{
Timer tmp = Interlocked.Exchange(ref _keyExchangeTimer, null);
if (tmp != null)
{
tmp.Dispose();
}
_keyExchanged = true;
SetState(RemoteSessionState.Established, eventArgs.Reason);
if (_pendingDisconnect)
{
//session key exchange is complete, if there is a disconnect pending, process it now
_pendingDisconnect = false;
DoDisconnect(sender, eventArgs);
}
}
}
break;
case RemoteSessionEvent.KeySent:
{
Dbg.Assert(_state >= RemoteSessionState.Established,
"Client can send a public key only after reaching the Established state");
Dbg.Assert(_keyExchanged == false, "Client should do key exchange only once");
if (_state == RemoteSessionState.Established ||
_state == RemoteSessionState.EstablishedAndKeyRequested)
{
SetState(RemoteSessionState.EstablishedAndKeySent, eventArgs.Reason);
// start the timer and wait
_keyExchangeTimer = new Timer(HandleKeyExchangeTimeout, null, BaseTransportManager.ClientDefaultOperationTimeoutMs, Timeout.Infinite);
}
}
break;
case RemoteSessionEvent.DisconnectCompleted:
{
Dbg.Assert(_state == RemoteSessionState.Disconnecting || _state == RemoteSessionState.RCDisconnecting,
"DisconnectCompleted event received while state machine is in wrong state");
if (_state == RemoteSessionState.Disconnecting || _state == RemoteSessionState.RCDisconnecting)
{
SetState(RemoteSessionState.Disconnected, eventArgs.Reason);
}
}
break;
case RemoteSessionEvent.DisconnectFailed:
{
Dbg.Assert(_state == RemoteSessionState.Disconnecting,
"DisconnectCompleted event received while state machine is in wrong state");
if (_state == RemoteSessionState.Disconnecting)
{
SetState(RemoteSessionState.Disconnected, eventArgs.Reason); //set state to disconnected even TODO. Put some ETW event describing the disconnect process failure
}
}
break;
case RemoteSessionEvent.ReconnectCompleted:
{
Dbg.Assert(_state == RemoteSessionState.Reconnecting,
"ReconnectCompleted event received while state machine is in wrong state");
if (_state == RemoteSessionState.Reconnecting)
{
SetState(RemoteSessionState.Established, eventArgs.Reason);
}
}
break;
} // switch...
}
/// <summary>
/// Opens the Uri. System's default application will be used
/// to show the uri.
/// </summary>
/// <param name="uriToLaunch"></param>
private void LaunchOnlineHelp(Uri uriToLaunch)
{
Diagnostics.Assert(uriToLaunch != null, "uriToLaunch should not be null");
if (!uriToLaunch.Scheme.Equals("http", StringComparison.OrdinalIgnoreCase) &&
!uriToLaunch.Scheme.Equals("https", StringComparison.OrdinalIgnoreCase))
{
throw PSTraceSource.NewInvalidOperationException(HelpErrors.ProtocolNotSupported,
uriToLaunch.ToString(),
"http",
"https");
}
// we use this test hook is to avoid actually calling out to another process
if (InternalTestHooks.BypassOnlineHelpRetrieval)
{
this.WriteObject(string.Format(CultureInfo.InvariantCulture, HelpDisplayStrings.OnlineHelpUri, uriToLaunch.OriginalString));
return;
}
Exception exception = null;
bool wrapCaughtException = true;
try
{
this.WriteVerbose(string.Format(CultureInfo.InvariantCulture, HelpDisplayStrings.OnlineHelpUri, uriToLaunch.OriginalString));
System.Diagnostics.Process browserProcess = new System.Diagnostics.Process();
if (Platform.IsNanoServer || Platform.IsIoT)
{
// We cannot open the URL in browser on headless SKUs.
wrapCaughtException = false;
exception = PSTraceSource.NewInvalidOperationException(HelpErrors.CannotLaunchURI, uriToLaunch.OriginalString);
}
else
{
browserProcess.StartInfo.FileName = uriToLaunch.OriginalString;
browserProcess.StartInfo.UseShellExecute = true;
browserProcess.Start();
}
}
catch (InvalidOperationException ioe)
{
exception = ioe;
}
catch (System.ComponentModel.Win32Exception we)
{
exception = we;
}
if (exception != null)
{
if (wrapCaughtException)
{
throw PSTraceSource.NewInvalidOperationException(exception, HelpErrors.CannotLaunchURI, uriToLaunch.OriginalString);
}
else
{
throw exception;
}
}
}
/// <summary>
/// Closes the content readers and writers in the content holder array.
/// </summary>
internal void CloseContent(List <ContentHolder> contentHolders, bool disposing)
{
if (contentHolders == null)
{
throw PSTraceSource.NewArgumentNullException("contentHolders");
}
foreach (ContentHolder holder in contentHolders)
{
try
{
if (holder.Writer != null)
{
holder.Writer.Close();
}
}
catch (Exception e) // Catch-all OK. 3rd party callout
{
// Catch all the exceptions caused by closing the writer
// and write out an error.
ProviderInvocationException providerException =
new ProviderInvocationException(
"ProviderContentCloseError",
SessionStateStrings.ProviderContentCloseError,
holder.PathInfo.Provider,
holder.PathInfo.Path,
e);
// Log a provider health event
MshLog.LogProviderHealthEvent(
this.Context,
holder.PathInfo.Provider.Name,
providerException,
Severity.Warning);
if (!disposing)
{
WriteError(
new ErrorRecord(
providerException.ErrorRecord,
providerException));
}
}
try
{
if (holder.Reader != null)
{
holder.Reader.Close();
}
}
catch (Exception e) // Catch-all OK. 3rd party callout
{
// Catch all the exceptions caused by closing the writer
// and write out an error.
ProviderInvocationException providerException =
new ProviderInvocationException(
"ProviderContentCloseError",
SessionStateStrings.ProviderContentCloseError,
holder.PathInfo.Provider,
holder.PathInfo.Path,
e);
// Log a provider health event
MshLog.LogProviderHealthEvent(
this.Context,
holder.PathInfo.Provider.Name,
providerException,
Severity.Warning);
if (!disposing)
{
WriteError(
new ErrorRecord(
providerException.ErrorRecord,
providerException));
}
}
}
}
/// <summary>
/// Implements the ProcessRecord() method for get-help command
/// </summary>
protected override void ProcessRecord()
{
try
{
this.Context.HelpSystem.OnProgress += new HelpSystem.HelpProgressHandler(HelpSystem_OnProgress);
bool failed = false;
HelpCategory helpCategory = ToHelpCategory(Category, ref failed);
if (failed)
{
return;
}
// Validate input parameters
ValidateAndThrowIfError(helpCategory);
HelpRequest helpRequest = new HelpRequest(this.Name, helpCategory);
helpRequest.Provider = _provider;
helpRequest.Component = Component;
helpRequest.Role = Role;
helpRequest.Functionality = Functionality;
helpRequest.ProviderContext = new ProviderContext(
this.Path,
this.Context.Engine.Context,
this.SessionState.Path);
helpRequest.CommandOrigin = this.MyInvocation.CommandOrigin;
// the idea is to use yield statement in the help lookup to speed up
// perceived user experience....So HelpSystem.GetHelp returns an
// IEnumerable..
IEnumerable <HelpInfo> helpInfos = this.Context.HelpSystem.GetHelp(helpRequest);
// HelpCommand acts differently when there is just one help object and when
// there are more than one object...so handling this behavior through
// some variables.
HelpInfo firstHelpInfoObject = null;
int countOfHelpInfos = 0;
foreach (HelpInfo helpInfo in helpInfos)
{
// honor Ctrl-C from user.
if (IsStopping)
{
return;
}
if (0 == countOfHelpInfos)
{
firstHelpInfoObject = helpInfo;
}
else
{
// write first help object only once.
if (firstHelpInfoObject != null)
{
WriteObjectsOrShowOnlineHelp(firstHelpInfoObject, false);
firstHelpInfoObject = null;
}
WriteObjectsOrShowOnlineHelp(helpInfo, false);
}
countOfHelpInfos++;
}
_timer.Stop();
#if LEGACYTELEMETRY
if (!string.IsNullOrEmpty(Name))
{
Microsoft.PowerShell.Telemetry.Internal.TelemetryAPI.ReportGetHelpTelemetry(Name, countOfHelpInfos, _timer.ElapsedMilliseconds, _updatedHelp);
}
#endif
// Write full help as there is only one help info object
if (1 == countOfHelpInfos)
{
WriteObjectsOrShowOnlineHelp(firstHelpInfoObject, true);
}
else if (_showOnlineHelp && (countOfHelpInfos > 1))
{
throw PSTraceSource.NewInvalidOperationException(HelpErrors.MultipleOnlineTopicsNotSupported, "Online");
}
// show errors only if there is no wildcard search or VerboseHelpErrors is true.
if (((countOfHelpInfos == 0) && (!WildcardPattern.ContainsWildcardCharacters(helpRequest.Target))) ||
this.Context.HelpSystem.VerboseHelpErrors)
{
// Check if there is any error happened. If yes,
// pipe out errors.
if (this.Context.HelpSystem.LastErrors.Count > 0)
{
foreach (ErrorRecord errorRecord in this.Context.HelpSystem.LastErrors)
{
WriteError(errorRecord);
}
}
}
}
finally
{
this.Context.HelpSystem.OnProgress -= new HelpSystem.HelpProgressHandler(HelpSystem_OnProgress);
// finally clear the ScriptBlockAst -> Token[] cache
this.Context.HelpSystem.ClearScriptBlockTokenCache();
}
}
internal static void ResetTracer()
{
s_activeTracer = s_classTracer;
}
internal static void SetTracer(PSTraceSource t)
{
s_activeTracer = t;
}
public object VisitNamedAttributeArgument(NamedAttributeArgumentAst namedAttributeArgumentAst)
{
throw PSTraceSource.NewArgumentException(nameof(namedAttributeArgumentAst));
}
/// <summary>
/// Sets the alias of the specified name to the specified value
/// </summary>
/// <param name="name">
/// The name of the alias to set.
/// </param>
/// <param name="value">
/// The new value for the alias.
/// </param>
/// <param name="writeItem">
/// If true, the item that was set should be written to WriteItemObject.
/// </param>
#pragma warning disable 0162
internal override void SetSessionStateItem(string name, object value, bool writeItem)
{
Dbg.Diagnostics.Assert(
!String.IsNullOrEmpty(name),
"The caller should verify this parameter");
AliasProviderDynamicParameters dynamicParameters =
DynamicParameters as AliasProviderDynamicParameters;
AliasInfo item = null;
bool dynamicParametersSpecified = dynamicParameters != null && dynamicParameters.OptionsSet;
if (value == null)
{
if (dynamicParametersSpecified)
{
item = (AliasInfo)GetSessionStateItem(name);
if (item != null)
{
item.SetOptions(dynamicParameters.Options, Force);
}
}
else
{
RemoveSessionStateItem(name);
}
}
else
{
do // false loop
{
string stringValue = value as string;
if (stringValue != null)
{
if (dynamicParametersSpecified)
{
item = SessionState.Internal.SetAliasValue(name, stringValue, dynamicParameters.Options, Force, Context.Origin);
}
else
{
item = SessionState.Internal.SetAliasValue(name, stringValue, Force, Context.Origin);
}
break;
}
AliasInfo alias = value as AliasInfo;
if (alias != null)
{
AliasInfo newAliasInfo =
new AliasInfo(
name,
alias.Definition,
this.Context.ExecutionContext,
alias.Options);
if (dynamicParametersSpecified)
{
newAliasInfo.SetOptions(dynamicParameters.Options, Force);
}
item = SessionState.Internal.SetAliasItem(newAliasInfo, Force, Context.Origin);
break;
}
throw PSTraceSource.NewArgumentException("value");
} while (false);
}
if (writeItem && item != null)
{
WriteItemObject(item, item.Name, false);
}
}
public object VisitParameter(ParameterAst parameterAst)
{
throw PSTraceSource.NewArgumentException(nameof(parameterAst));
}
public object VisitMemberExpression(MemberExpressionAst memberExpressionAst)
{
throw PSTraceSource.NewArgumentException(nameof(memberExpressionAst));
}
public object VisitIfStatement(IfStatementAst ifStmtAst)
{
throw PSTraceSource.NewArgumentException(nameof(ifStmtAst));
}
public object VisitErrorExpression(ErrorExpressionAst errorExpressionAst)
{
throw PSTraceSource.NewArgumentException(nameof(errorExpressionAst));
}
public object VisitDataStatement(DataStatementAst dataStatementAst)
{
throw PSTraceSource.NewArgumentException(nameof(dataStatementAst));
}
public object VisitScriptBlock(ScriptBlockAst scriptBlockAst)
{
throw PSTraceSource.NewArgumentException(nameof(scriptBlockAst));
}
public object VisitWhileStatement(WhileStatementAst whileStatementAst)
{
throw PSTraceSource.NewArgumentException(nameof(whileStatementAst));
}
public object VisitNamedBlock(NamedBlockAst namedBlockAst)
{
throw PSTraceSource.NewArgumentException(nameof(namedBlockAst));
}
public object VisitBreakStatement(BreakStatementAst breakStatementAst)
{
throw PSTraceSource.NewArgumentException(nameof(breakStatementAst));
}
public object VisitTypeConstraint(TypeConstraintAst typeConstraintAst)
{
throw PSTraceSource.NewArgumentException(nameof(typeConstraintAst));
}
public object VisitReturnStatement(ReturnStatementAst returnStatementAst)
{
throw PSTraceSource.NewArgumentException(nameof(returnStatementAst));
}
public object VisitAttribute(AttributeAst attributeAst)
{
throw PSTraceSource.NewArgumentException(nameof(attributeAst));
}
public object VisitThrowStatement(ThrowStatementAst throwStatementAst)
{
throw PSTraceSource.NewArgumentException(nameof(throwStatementAst));
}
/// <summary>
/// Opens the Uri. System's default application will be used
/// to show the uri.
/// </summary>
/// <param name="uriToLaunch"></param>
private void LaunchOnlineHelp(Uri uriToLaunch)
{
Diagnostics.Assert(null != uriToLaunch, "uriToLaunch should not be null");
if (!uriToLaunch.Scheme.Equals("http", StringComparison.OrdinalIgnoreCase) &&
!uriToLaunch.Scheme.Equals("https", StringComparison.OrdinalIgnoreCase))
{
throw PSTraceSource.NewInvalidOperationException(HelpErrors.ProtocolNotSupported,
uriToLaunch.ToString(),
"http",
"https");
}
// we use this test hook is to avoid actually calling out to another process
if (InternalTestHooks.BypassOnlineHelpRetrieval)
{
this.WriteObject(string.Format(CultureInfo.InvariantCulture, HelpDisplayStrings.OnlineHelpUri, uriToLaunch.OriginalString));
return;
}
Exception exception = null;
bool wrapCaughtException = true;
try
{
this.WriteVerbose(string.Format(CultureInfo.InvariantCulture, HelpDisplayStrings.OnlineHelpUri, uriToLaunch.OriginalString));
System.Diagnostics.Process browserProcess = new System.Diagnostics.Process();
#if UNIX
browserProcess.StartInfo.FileName = Platform.IsLinux ? "xdg-open" : /* OS X */ "open";
browserProcess.StartInfo.Arguments = uriToLaunch.OriginalString;
browserProcess.Start();
#elif CORECLR
// On FullCLR, ProcessStartInfo.UseShellExecute is true by default. This means that the shell will be used when starting the process.
// On CoreCLR, UseShellExecute is not supported. To work around this, we check if there is a default browser in the system.
// If there is, we lunch it to open the HelpURI. If there isn't, we error out.
string webBrowserPath = GetDefaultWebBrowser();
if (webBrowserPath == null)
{
wrapCaughtException = false;
exception = PSTraceSource.NewInvalidOperationException(HelpErrors.CannotLaunchURI, uriToLaunch.OriginalString);
}
else
{
browserProcess.StartInfo = new ProcessStartInfo(webBrowserPath);
browserProcess.StartInfo.Arguments = "\"" + uriToLaunch.OriginalString + "\"";
browserProcess.Start();
}
#else
browserProcess.StartInfo.FileName = uriToLaunch.OriginalString;
browserProcess.Start();
#endif
}
catch (InvalidOperationException ioe)
{
exception = ioe;
}
catch (System.ComponentModel.Win32Exception we)
{
exception = we;
}
if (null != exception)
{
if (wrapCaughtException)
{
throw PSTraceSource.NewInvalidOperationException(exception, HelpErrors.CannotLaunchURI, uriToLaunch.OriginalString);
}
else
{
throw exception;
}
}
}
