internal CommandNotFoundException(
string commandName,
Exception innerException,
string errorIdAndResourceId,
params object[] messageArgs)
: base(CommandNotFoundException.BuildMessage(commandName, errorIdAndResourceId, messageArgs), innerException)
{
this.commandName = commandName;
this._errorId = errorIdAndResourceId;
}
private void Init(CmdletInfo cmdletInformation)
{
Cmdlet cmdlet = (Cmdlet)null;
Exception exception = (Exception)null;
string errorIdAndResourceId = "CmdletNotFoundException";
try
{
cmdlet = (Cmdlet)Activator.CreateInstance(cmdletInformation.ImplementingType);
}
catch (TargetInvocationException ex)
{
CommandProcessor.tracer.TraceException((Exception)ex);
CmdletInvocationException invocationException = new CmdletInvocationException(ex.InnerException, (InvocationInfo)null);
MshLog.LogCommandHealthEvent(this.context, (Exception)invocationException, Severity.Warning);
throw invocationException;
}
catch (MemberAccessException ex)
{
exception = (Exception)ex;
}
catch (TypeLoadException ex)
{
exception = (Exception)ex;
}
catch (InvalidCastException ex)
{
exception = (Exception)ex;
errorIdAndResourceId = "CmdletDoesNotDeriveFromCmdletType";
}
catch (Exception ex)
{
CommandProcessorBase.CheckForSevereException(ex);
CommandProcessor.tracer.TraceException(ex);
MshLog.LogCommandHealthEvent(this.context, ex, Severity.Warning);
throw;
}
if (exception != null)
{
CommandProcessor.tracer.TraceException(exception);
MshLog.LogCommandHealthEvent(this.context, exception, Severity.Warning);
CommandNotFoundException notFoundException = new CommandNotFoundException(cmdletInformation.Name, exception, errorIdAndResourceId, new object[1]
{
(object)exception.Message
});
CommandProcessor.tracer.TraceException((Exception)notFoundException);
throw notFoundException;
}
this.Command = (InternalCommand)cmdlet;
this.InitCommon();
}
private void Init(CmdletInfo cmdletInformation)
{
Cmdlet cmdlet = null;
Exception exception = null;
string str = null;
string cmdletDoesNotDeriveFromCmdletType = null;
try
{
cmdlet = ConstructInstance(cmdletInformation.ImplementingType);
if (cmdlet == null)
{
exception = new InvalidCastException();
str = "CmdletDoesNotDeriveFromCmdletType";
cmdletDoesNotDeriveFromCmdletType = DiscoveryExceptions.CmdletDoesNotDeriveFromCmdletType;
}
}
catch (MemberAccessException exception2)
{
exception = exception2;
}
catch (TypeLoadException exception3)
{
exception = exception3;
}
catch (Exception exception4)
{
CommandProcessorBase.CheckForSevereException(exception4);
CmdletInvocationException exception5 = new CmdletInvocationException(exception4, null);
MshLog.LogCommandHealthEvent(base._context, exception5, Severity.Warning);
throw exception5;
}
if (exception != null)
{
MshLog.LogCommandHealthEvent(base._context, exception, Severity.Warning);
CommandNotFoundException exception6 = new CommandNotFoundException(cmdletInformation.Name, exception, str ?? "CmdletNotFoundException", cmdletDoesNotDeriveFromCmdletType ?? DiscoveryExceptions.CmdletNotFoundException, new object[] { exception.Message });
throw exception6;
}
base.Command = cmdlet;
base.CommandScope = base.Context.EngineSessionState.CurrentScope;
this.InitCommon();
}
private void Init(CmdletInfo cmdletInformation)
{
Cmdlet cmdlet = null;
Exception exception = null;
string str = null;
string cmdletDoesNotDeriveFromCmdletType = null;
try
{
cmdlet = ConstructInstance(cmdletInformation.ImplementingType);
if (cmdlet == null)
{
exception = new InvalidCastException();
str = "CmdletDoesNotDeriveFromCmdletType";
cmdletDoesNotDeriveFromCmdletType = DiscoveryExceptions.CmdletDoesNotDeriveFromCmdletType;
}
}
catch (MemberAccessException exception2)
{
exception = exception2;
}
catch (TypeLoadException exception3)
{
exception = exception3;
}
catch (Exception exception4)
{
CommandProcessorBase.CheckForSevereException(exception4);
CmdletInvocationException exception5 = new CmdletInvocationException(exception4, null);
MshLog.LogCommandHealthEvent(base._context, exception5, Severity.Warning);
throw exception5;
}
if (exception != null)
{
MshLog.LogCommandHealthEvent(base._context, exception, Severity.Warning);
CommandNotFoundException exception6 = new CommandNotFoundException(cmdletInformation.Name, exception, str ?? "CmdletNotFoundException", cmdletDoesNotDeriveFromCmdletType ?? DiscoveryExceptions.CmdletNotFoundException, new object[] { exception.Message });
throw exception6;
}
base.Command = cmdlet;
base.CommandScope = base.Context.EngineSessionState.CurrentScope;
this.InitCommon();
}
internal static void ShouldRun(
ExecutionContext context,
PSHost host,
CommandInfo commandInfo,
CommandOrigin commandOrigin)
{
try
{
if (commandOrigin == CommandOrigin.Runspace && commandInfo.Visibility != SessionStateEntryVisibility.Public)
{
CommandNotFoundException notFoundException = new CommandNotFoundException(commandInfo.Name, (Exception)null, "CommandNotFoundException", new object[0]);
CommandDiscovery.tracer.TraceException((Exception)notFoundException);
throw notFoundException;
}
context.AuthorizationManager.ShouldRunInternal(commandInfo, commandOrigin, host);
}
catch (PSSecurityException ex)
{
CommandDiscovery.tracer.TraceException((Exception)ex);
MshLog.LogCommandHealthEvent(context, (Exception)ex, Severity.Warning);
MshLog.LogCommandLifecycleEvent(context, CommandState.Terminated, commandInfo.Name);
throw;
}
}
/// <summary>
/// Initializes the command's request object.
/// </summary>
/// <param name="cmdletInformation">
/// The information about the cmdlet.
/// </param>
/// <exception cref="CmdletInvocationException">
/// If the constructor for the cmdlet threw an exception.
/// </exception>
/// <exception cref="MemberAccessException">
/// The type referenced by <paramref name="cmdletInformation"/> refered to an
/// abstract type or them member was invoked via a late-binding mechanism.
/// </exception>
/// <exception cref="TypeLoadException">
/// If <paramref name="cmdletInformation"/> refers to a type that is invalid.
/// </exception>
private void Init(CmdletInfo cmdletInformation)
{
Diagnostics.Assert(cmdletInformation != null, "Constructor should throw exception if LookupCommand returned null.");
Cmdlet newCmdlet = null;
Exception initError = null;
string errorIdAndResourceId = null;
string resourceStr = null;
try
{
// Create the request object
newCmdlet = ConstructInstance(cmdletInformation.ImplementingType);
if (newCmdlet == null)
{
// We could test the inheritance before constructing, but that's
// expensive. Much cheaper to just check for null.
initError = new InvalidCastException();
errorIdAndResourceId = "CmdletDoesNotDeriveFromCmdletType";
resourceStr = DiscoveryExceptions.CmdletDoesNotDeriveFromCmdletType;
}
}
catch (MemberAccessException memberAccessException)
{
initError = memberAccessException;
}
catch (TypeLoadException typeLoadException)
{
initError = typeLoadException;
}
catch (Exception e) // Catch-all OK, 3rd party callout.
{
// We don't have a Command or InvocationInfo at this point,
// since the command failed to initialize.
var commandException = new CmdletInvocationException(e, null);
// Log a command health event
MshLog.LogCommandHealthEvent(
this._context,
commandException,
Severity.Warning);
throw commandException;
}
if (initError != null)
{
// Log a command health event
MshLog.LogCommandHealthEvent(
this._context,
initError,
Severity.Warning);
CommandNotFoundException exception =
new CommandNotFoundException(
cmdletInformation.Name,
initError,
errorIdAndResourceId ?? "CmdletNotFoundException",
resourceStr ?? DiscoveryExceptions.CmdletNotFoundException,
initError.Message);
throw exception;
}
this.Command = newCmdlet;
this.CommandScope = Context.EngineSessionState.CurrentScope;
InitCommon();
}
private static void ThrowCommandNotFoundException(Exception innerException)
{
CommandNotFoundException cmdE = new CommandNotFoundException(innerException.Message, innerException);
throw cmdE;
}
private static CommandInfo TryModuleAutoLoading(string commandName, ExecutionContext context, string originalCommandName, CommandOrigin commandOrigin, CommandInfo result, ref Exception lastError)
{
int length = commandName.IndexOfAny(new char[] { ':', '\\' });
if ((length == -1) || (commandName[length] == ':'))
{
return null;
}
string str = commandName.Substring(0, length);
string str2 = commandName.Substring(length + 1, (commandName.Length - length) - 1);
if ((string.IsNullOrEmpty(str) || string.IsNullOrEmpty(str2)) || str.EndsWith(".", StringComparison.Ordinal))
{
return null;
}
try
{
discoveryTracer.WriteLine("Executing module-qualified search: {0}", new object[] { commandName });
context.CommandDiscovery.RegisterLookupCommandInfoAction("ActiveModuleSearch", commandName);
CmdletInfo cmdlet = context.SessionState.InvokeCommand.GetCmdlet(@"Microsoft.PowerShell.Core\Import-Module");
if ((commandOrigin == CommandOrigin.Internal) || ((cmdlet != null) && (cmdlet.Visibility == SessionStateEntryVisibility.Public)))
{
List<PSModuleInfo> modules = context.Modules.GetModules(new string[] { str }, false);
PSModuleInfo info2 = null;
if ((modules == null) || (modules.Count == 0))
{
CommandInfo commandInfo = new CmdletInfo("Import-Module", typeof(ImportModuleCommand), null, null, context) {
Visibility = cmdlet.Visibility
};
Command command = new Command(commandInfo);
Collection<PSModuleInfo> collection = null;
discoveryTracer.WriteLine("Attempting to load module: {0}", new object[] { str });
try
{
collection = PowerShell.Create(RunspaceMode.CurrentRunspace).AddCommand(command).AddParameter("Name", str).AddParameter("Scope", "GLOBAL").AddParameter("ErrorAction", ActionPreference.Ignore).AddParameter("PassThru").AddParameter("WarningAction", ActionPreference.Ignore).AddParameter("Verbose", false).AddParameter("Debug", false).Invoke<PSModuleInfo>();
}
catch (Exception exception)
{
discoveryTracer.WriteLine("Encountered error importing module: {0}", new object[] { exception.Message });
lastError = exception;
CommandProcessorBase.CheckForSevereException(exception);
}
if ((collection == null) || (collection.Count == 0))
{
string resourceStr = StringUtil.Format(DiscoveryExceptions.CouldNotAutoImportModule, str);
CommandNotFoundException exception2 = new CommandNotFoundException(originalCommandName, lastError, "CouldNotAutoLoadModule", resourceStr, new object[0]);
throw exception2;
}
info2 = collection[0];
}
else
{
info2 = modules[0];
}
if (info2.ExportedCommands.ContainsKey(str2))
{
result = info2.ExportedCommands[str2];
}
}
return result;
}
catch (CommandNotFoundException)
{
throw;
}
catch (Exception exception3)
{
CommandProcessorBase.CheckForSevereException(exception3);
}
finally
{
context.CommandDiscovery.UnregisterLookupCommandInfoAction("ActiveModuleSearch", commandName);
}
return result;
}
private static CommandInfo TryModuleAutoDiscovery(string commandName, ExecutionContext context, string originalCommandName, CommandOrigin commandOrigin, SearchResolutionOptions searchResolutionOptions, CommandTypes commandTypes, ref Exception lastError)
{
CommandInfo info = null;
try
{
CmdletInfo cmdlet = context.SessionState.InvokeCommand.GetCmdlet(@"Microsoft.PowerShell.Core\Get-Module");
if ((commandOrigin == CommandOrigin.Internal) || ((cmdlet != null) && (cmdlet.Visibility == SessionStateEntryVisibility.Public)))
{
cmdlet = context.SessionState.InvokeCommand.GetCmdlet(@"Microsoft.PowerShell.Core\Import-Module");
if ((commandOrigin == CommandOrigin.Internal) || ((cmdlet != null) && (cmdlet.Visibility == SessionStateEntryVisibility.Public)))
{
discoveryTracer.WriteLine("Executing non module-qualified search: {0}", new object[] { commandName });
context.CommandDiscovery.RegisterLookupCommandInfoAction("ActiveModuleSearch", commandName);
foreach (string str in ModuleUtils.GetDefaultAvailableModuleFiles(true, true, context))
{
string fileNameWithoutExtension = Path.GetFileNameWithoutExtension(str);
Dictionary<string, List<CommandTypes>> dictionary = AnalysisCache.GetExportedCommands(str, false, context);
if (dictionary != null)
{
if (dictionary.ContainsKey(commandName))
{
CommandInfo commandInfo = new CmdletInfo("Import-Module", typeof(ImportModuleCommand), null, null, context) {
Visibility = cmdlet.Visibility
};
Command command = new Command(commandInfo);
discoveryTracer.WriteLine("Found in module: {0}", new object[] { str });
PowerShell shell = PowerShell.Create(RunspaceMode.CurrentRunspace).AddCommand(command).AddParameter("Name", str).AddParameter("Scope", "GLOBAL").AddParameter("PassThru").AddParameter("ErrorAction", ActionPreference.Ignore).AddParameter("WarningAction", ActionPreference.Ignore).AddParameter("Verbose", false).AddParameter("Debug", false);
Collection<PSModuleInfo> collection = null;
try
{
collection = shell.Invoke<PSModuleInfo>();
}
catch (Exception exception)
{
discoveryTracer.WriteLine("Encountered error importing module: {0}", new object[] { exception.Message });
lastError = exception;
CommandProcessorBase.CheckForSevereException(exception);
}
if ((collection == null) || (collection.Count == 0))
{
string resourceStr = StringUtil.Format(DiscoveryExceptions.CouldNotAutoImportMatchingModule, commandName, fileNameWithoutExtension);
CommandNotFoundException exception2 = new CommandNotFoundException(originalCommandName, lastError, "CouldNotAutoloadMatchingModule", resourceStr, new object[0]);
throw exception2;
}
info = LookupCommandInfo(commandName, commandTypes, searchResolutionOptions, commandOrigin, context);
}
if (info != null)
{
return info;
}
}
}
}
return info;
}
return info;
}
catch (CommandNotFoundException)
{
throw;
}
catch (Exception exception3)
{
CommandProcessorBase.CheckForSevereException(exception3);
}
finally
{
context.CommandDiscovery.UnregisterLookupCommandInfoAction("ActiveModuleSearch", commandName);
}
return info;
}
internal static void ShouldRun(ExecutionContext context, PSHost host, CommandInfo commandInfo, CommandOrigin commandOrigin)
{
try
{
if ((commandOrigin == CommandOrigin.Runspace) && (commandInfo.Visibility != SessionStateEntryVisibility.Public))
{
CommandNotFoundException exception = new CommandNotFoundException(commandInfo.Name, null, "CommandNotFoundException", DiscoveryExceptions.CommandNotFoundException, new object[0]);
throw exception;
}
context.AuthorizationManager.ShouldRunInternal(commandInfo, commandOrigin, host);
}
catch (PSSecurityException exception2)
{
MshLog.LogCommandHealthEvent(context, exception2, Severity.Warning);
MshLog.LogCommandLifecycleEvent(context, CommandState.Terminated, commandInfo.Name);
throw;
}
}
internal CommandProcessorBase LookupCommandProcessor(CommandInfo commandInfo, CommandOrigin commandOrigin, bool? useLocalScope, SessionStateInternal sessionState)
{
CommandProcessorBase base2 = null;
FunctionInfo info3;
CommandNotFoundException exception6;
HashSet<string> set = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
while (((commandInfo.CommandType == CommandTypes.Alias) && !set.Contains(commandInfo.Name)) && ((commandOrigin == CommandOrigin.Internal) || (commandInfo.Visibility == SessionStateEntryVisibility.Public)))
{
set.Add(commandInfo.Name);
AliasInfo info = (AliasInfo) commandInfo;
commandInfo = info.ResolvedCommand;
if (commandInfo == null)
{
commandInfo = LookupCommandInfo(info.Definition, commandOrigin, this._context);
}
if (commandInfo == null)
{
CommandNotFoundException exception = new CommandNotFoundException(info.Name, null, "AliasNotResolvedException", DiscoveryExceptions.AliasNotResolvedException, new object[] { info.UnresolvedCommandName });
throw exception;
}
PSSQMAPI.IncrementData(CommandTypes.Alias);
}
ShouldRun(this._context, this._context.EngineHostInterface, commandInfo, commandOrigin);
CommandTypes commandType = commandInfo.CommandType;
if (commandType <= CommandTypes.ExternalScript)
{
switch (commandType)
{
case CommandTypes.Function:
case CommandTypes.Filter:
goto Label_01E3;
case CommandTypes.Cmdlet:
base2 = new CommandProcessor((CmdletInfo) commandInfo, this._context);
goto Label_0260;
case CommandTypes.ExternalScript:
{
ExternalScriptInfo scriptInfo = (ExternalScriptInfo) commandInfo;
scriptInfo.SignatureChecked = true;
try
{
if (!this._context.IsSingleShell)
{
bool? nullable = useLocalScope;
base2 = this.CreateScriptProcessorForMiniShell(scriptInfo, nullable.HasValue ? nullable.GetValueOrDefault() : true, sessionState);
}
else
{
bool? nullable2 = useLocalScope;
base2 = this.CreateScriptProcessorForSingleShell(scriptInfo, this._context, nullable2.HasValue ? nullable2.GetValueOrDefault() : true, sessionState);
}
goto Label_0260;
}
catch (ScriptRequiresSyntaxException exception2)
{
CommandNotFoundException exception3 = new CommandNotFoundException(exception2.Message, exception2);
throw exception3;
}
catch (PSArgumentException exception4)
{
CommandNotFoundException exception5 = new CommandNotFoundException(commandInfo.Name, exception4, "ScriptRequiresInvalidFormat", DiscoveryExceptions.ScriptRequiresInvalidFormat, new object[0]);
throw exception5;
}
goto Label_01E3;
}
}
goto Label_023F;
}
if (commandType != CommandTypes.Application)
{
if (commandType == CommandTypes.Script)
{
bool? nullable4 = useLocalScope;
base2 = CreateCommandProcessorForScript((ScriptInfo) commandInfo, this._context, nullable4.HasValue ? nullable4.GetValueOrDefault() : true, sessionState);
goto Label_0260;
}
if (commandType == CommandTypes.Workflow)
{
goto Label_01E3;
}
goto Label_023F;
}
base2 = new NativeCommandProcessor((ApplicationInfo) commandInfo, this._context);
goto Label_0260;
Label_01E3:
info3 = (FunctionInfo) commandInfo;
bool? nullable3 = useLocalScope;
base2 = CreateCommandProcessorForScript(info3, this._context, nullable3.HasValue ? nullable3.GetValueOrDefault() : true, sessionState);
goto Label_0260;
Label_023F:
exception6 = new CommandNotFoundException(commandInfo.Name, null, "CommandNotFoundException", DiscoveryExceptions.CommandNotFoundException, new object[0]);
throw exception6;
Label_0260:
PSSQMAPI.IncrementData(commandInfo.CommandType);
base2.Command.CommandOriginInternal = commandOrigin;
base2.Command.MyInvocation.InvocationName = commandInfo.Name;
return base2;
}
internal static CommandInfo LookupCommandInfo(string commandName, CommandTypes commandTypes, SearchResolutionOptions searchResolutionOptions, CommandOrigin commandOrigin, ExecutionContext context)
{
if (string.IsNullOrEmpty(commandName))
{
return null;
}
CommandInfo result = null;
string command = commandName;
Exception lastError = null;
CommandLookupEventArgs e = null;
EventHandler<CommandLookupEventArgs> preCommandLookupAction = context.EngineIntrinsics.InvokeCommand.PreCommandLookupAction;
if (preCommandLookupAction != null)
{
discoveryTracer.WriteLine("Executing PreCommandLookupAction: {0}", new object[] { commandName });
try
{
context.CommandDiscovery.RegisterLookupCommandInfoAction("ActivePreLookup", command);
e = new CommandLookupEventArgs(command, commandOrigin, context);
preCommandLookupAction(command, e);
discoveryTracer.WriteLine("PreCommandLookupAction returned: {0}", new object[] { e.Command });
}
catch (Exception exception2)
{
CommandProcessorBase.CheckForSevereException(exception2);
}
finally
{
context.CommandDiscovery.UnregisterLookupCommandInfoAction("ActivePreLookup", commandName);
}
}
if ((e == null) || !e.StopSearch)
{
discoveryTracer.WriteLine("Looking up command: {0}", new object[] { commandName });
result = TryNormalSearch(commandName, context, commandOrigin, searchResolutionOptions, commandTypes, ref lastError);
if (result == null)
{
PSModuleAutoLoadingPreference preference = GetCommandDiscoveryPreference(context, SpecialVariables.PSModuleAutoLoadingPreferenceVarPath, "PSModuleAutoLoadingPreference");
if (preference != PSModuleAutoLoadingPreference.None)
{
result = TryModuleAutoLoading(commandName, context, command, commandOrigin, result, ref lastError);
}
if (result == null)
{
if (preference == PSModuleAutoLoadingPreference.All)
{
result = TryModuleAutoDiscovery(commandName, context, command, commandOrigin, searchResolutionOptions, commandTypes, ref lastError);
}
if (result == null)
{
result = InvokeCommandNotFoundHandler(commandName, context, command, commandOrigin, result);
}
}
}
}
else if (e.Command != null)
{
result = e.Command;
}
if (result != null)
{
EventHandler<CommandLookupEventArgs> postCommandLookupAction = context.EngineIntrinsics.InvokeCommand.PostCommandLookupAction;
if (postCommandLookupAction != null)
{
discoveryTracer.WriteLine("Executing PostCommandLookupAction: {0}", new object[] { command });
try
{
context.CommandDiscovery.RegisterLookupCommandInfoAction("ActivePostCommand", command);
e = new CommandLookupEventArgs(command, commandOrigin, context) {
Command = result
};
postCommandLookupAction(command, e);
if (e != null)
{
result = e.Command;
discoveryTracer.WriteLine("PreCommandLookupAction returned: {0}", new object[] { e.Command });
}
}
catch (Exception exception3)
{
CommandProcessorBase.CheckForSevereException(exception3);
}
finally
{
context.CommandDiscovery.UnregisterLookupCommandInfoAction("ActivePostCommand", command);
}
}
}
if (result == null)
{
discoveryTracer.TraceError("'{0}' is not recognized as a cmdlet, function, operable program or script file.", new object[] { commandName });
CommandNotFoundException exception4 = new CommandNotFoundException(command, lastError, "CommandNotFoundException", DiscoveryExceptions.CommandNotFoundException, new object[0]);
throw exception4;
}
return result;
}
private static void ThrowCommandNotFoundException(Exception innerException)
{
CommandNotFoundException exception = new CommandNotFoundException(innerException.Message, innerException);
throw exception;
}
/// <summary>
/// Initializes the command's request object
/// </summary>
///
/// <param name="cmdletInformation">
/// The information about the cmdlet.
/// </param>
///
/// <exception cref="CmdletInvocationException">
/// If the constructor for the cmdlet threw an exception.
/// </exception>
///
/// <exception cref="MemberAccessException">
/// The type referenced by <paramref name="cmdletInformation"/> refered to an
/// abstract type or them member was invoked via a late-binding mechanism.
/// </exception>
///
/// <exception cref="TypeLoadException">
/// If <paramref name="cmdletInformation"/> refers to a type that is invalid.
/// </exception>
///
private void Init(CmdletInfo cmdletInformation)
{
Diagnostics.Assert(cmdletInformation != null, "Constructor should throw exception if LookupCommand returned null.");
Cmdlet newCmdlet = null;
Exception initError = null;
string errorIdAndResourceId = null;
string resourceStr = null;
try
{
// Create the request object
newCmdlet = ConstructInstance(cmdletInformation.ImplementingType);
if (newCmdlet == null)
{
// We could test the inheritance before constructing, but that's
// expensive. Much cheaper to just check for null.
initError = new InvalidCastException();
errorIdAndResourceId = "CmdletDoesNotDeriveFromCmdletType";
resourceStr = DiscoveryExceptions.CmdletDoesNotDeriveFromCmdletType;
}
}
catch (MemberAccessException memberAccessException)
{
initError = memberAccessException;
}
catch (TypeLoadException typeLoadException)
{
initError = typeLoadException;
}
catch (Exception e) // Catch-all OK, 3rd party callout.
{
CommandProcessorBase.CheckForSevereException(e);
// We don't have a Command or InvocationInfo at this point,
// since the command failed to initialize.
var commandException = new CmdletInvocationException(e, null);
// Log a command health event
MshLog.LogCommandHealthEvent(
this._context,
commandException,
Severity.Warning);
throw commandException;
}
if (null != initError)
{
// Log a command health event
MshLog.LogCommandHealthEvent(
this._context,
initError,
Severity.Warning);
CommandNotFoundException exception =
new CommandNotFoundException(
cmdletInformation.Name,
initError,
errorIdAndResourceId ?? "CmdletNotFoundException",
resourceStr ?? DiscoveryExceptions.CmdletNotFoundException,
initError.Message);
throw exception;
}
this.Command = newCmdlet;
this.CommandScope = Context.EngineSessionState.CurrentScope;
InitCommon();
}
internal CommandInfo LookupCommandInfo(
string commandName,
CommandOrigin commandOrigin)
{
CommandInfo commandInfo = (CommandInfo)null;
string commandName1 = commandName;
Exception innerException = (Exception)null;
while (true)
{
CommandDiscovery.discoveryTracer.WriteLine("Looking up command: {0}", (object)commandName);
if (!string.IsNullOrEmpty(commandName))
{
CommandSearcher commandSearcher = new CommandSearcher(commandName, SearchResolutionOptions.AllowDuplicateCmdletNames, CommandTypes.All, this._context);
commandSearcher.CommandOrigin = commandOrigin;
try
{
if (!commandSearcher.MoveNext())
{
if (!commandName.Contains("-"))
{
CommandDiscovery.discoveryTracer.WriteLine("The command [{0}] was not found, trying again with get- prepended", (object)commandName);
commandName = "get" + (object)'-' + commandName;
}
else
{
goto label_13;
}
}
else
{
commandInfo = ((IEnumerator <CommandInfo>)commandSearcher).Current;
goto label_13;
}
}
catch (ArgumentException ex)
{
innerException = (Exception)ex;
goto label_13;
}
catch (PathTooLongException ex)
{
innerException = (Exception)ex;
goto label_13;
}
catch (FileLoadException ex)
{
innerException = (Exception)ex;
goto label_13;
}
catch (FormatException ex)
{
innerException = (Exception)ex;
goto label_13;
}
catch (MetadataException ex)
{
innerException = (Exception)ex;
goto label_13;
}
}
else
{
break;
}
}
CommandDiscovery.discoveryTracer.TraceError("Command name empty or null");
label_13:
if (commandInfo == null)
{
CommandDiscovery.discoveryTracer.TraceError("'{0}' is not recognized as a cmdlet, function, operable program or script file.", (object)commandName);
CommandNotFoundException notFoundException = new CommandNotFoundException(commandName1, innerException, "CommandNotFoundException", new object[0]);
CommandDiscovery.tracer.TraceException((Exception)notFoundException);
throw notFoundException;
}
return(commandInfo);
}
internal CommandProcessorBase LookupCommandProcessor(
CommandInfo commandInfo,
CommandOrigin commandOrigin,
bool?useLocalScope)
{
if (commandInfo.CommandType == CommandTypes.Alias && (commandOrigin == CommandOrigin.Internal || commandInfo.Visibility == SessionStateEntryVisibility.Public))
{
AliasInfo aliasInfo = (AliasInfo)commandInfo;
commandInfo = aliasInfo.ResolvedCommand;
if (commandInfo == null)
{
CommandNotFoundException notFoundException = new CommandNotFoundException(aliasInfo.Name, (Exception)null, "AliasNotResolvedException", new object[1]
{
(object)aliasInfo.UnresolvedCommandName
});
CommandDiscovery.tracer.TraceException((Exception)notFoundException);
throw notFoundException;
}
PSSQMAPI.IncrementData(CommandTypes.Alias);
}
CommandDiscovery.ShouldRun(this._context, (PSHost)this._context.EngineHostInterface, commandInfo, commandOrigin);
CommandProcessorBase commandProcessorBase;
switch (commandInfo.CommandType)
{
case CommandTypes.Function:
case CommandTypes.Filter:
FunctionInfo functionInfo = (FunctionInfo)commandInfo;
ExecutionContext context1 = this._context;
bool? nullable1 = useLocalScope;
int num1 = nullable1.HasValue ? (nullable1.GetValueOrDefault() ? 1 : 0) : 1;
commandProcessorBase = CommandDiscovery.CreateCommandProcessorForScript(functionInfo, context1, num1 != 0);
break;
case CommandTypes.Cmdlet:
commandProcessorBase = (CommandProcessorBase) new CommandProcessor((CmdletInfo)commandInfo, this._context);
break;
case CommandTypes.ExternalScript:
ExternalScriptInfo externalScriptInfo = (ExternalScriptInfo)commandInfo;
externalScriptInfo.SignatureChecked = true;
try
{
if (!this._context.IsSingleShell)
{
ExternalScriptInfo scriptInfo = externalScriptInfo;
bool?nullable2 = useLocalScope;
int num2 = nullable2.HasValue ? (nullable2.GetValueOrDefault() ? 1 : 0) : 1;
commandProcessorBase = this.CreateScriptProcessorForMiniShell(scriptInfo, num2 != 0);
break;
}
ExternalScriptInfo scriptInfo1 = externalScriptInfo;
RunspaceConfigForSingleShell runspaceConfiguration = this._context.RunspaceConfiguration as RunspaceConfigForSingleShell;
bool?nullable3 = useLocalScope;
int num3 = nullable3.HasValue ? (nullable3.GetValueOrDefault() ? 1 : 0) : 1;
commandProcessorBase = this.CreateScriptProcessorForSingleShell(scriptInfo1, runspaceConfiguration, num3 != 0);
break;
}
catch (ScriptRequiresSyntaxException ex)
{
CommandNotFoundException notFoundException = new CommandNotFoundException(ex.Message, (Exception)ex);
CommandDiscovery.tracer.TraceException((Exception)notFoundException);
throw notFoundException;
}
catch (PSArgumentException ex)
{
CommandNotFoundException notFoundException = new CommandNotFoundException(commandInfo.Name, (Exception)ex, "ScriptRequiresInvalidFormat", new object[0]);
CommandDiscovery.tracer.TraceException((Exception)notFoundException);
throw notFoundException;
}
case CommandTypes.Application:
commandProcessorBase = (CommandProcessorBase) new NativeCommandProcessor((ApplicationInfo)commandInfo, this._context);
break;
case CommandTypes.Script:
ScriptInfo scriptInfo2 = (ScriptInfo)commandInfo;
ExecutionContext context2 = this._context;
bool? nullable4 = useLocalScope;
int num4 = nullable4.HasValue ? (nullable4.GetValueOrDefault() ? 1 : 0) : 1;
commandProcessorBase = CommandDiscovery.CreateCommandProcessorForScript(scriptInfo2, context2, num4 != 0);
break;
default:
CommandNotFoundException notFoundException1 = new CommandNotFoundException(commandInfo.Name, (Exception)null, "CommandNotFoundException", new object[0]);
CommandDiscovery.tracer.TraceException((Exception)notFoundException1);
throw notFoundException1;
}
PSSQMAPI.IncrementData(commandInfo.CommandType);
commandProcessorBase.Command.CommandOriginInternal = commandOrigin;
commandProcessorBase.Command.MyInvocation.InvocationName = commandInfo.Name;
return(commandProcessorBase);
}
