partial void BeforeCreatePipeline(System.Management.Automation.InvocationInfo invocationInfo, ref Runtime.HttpPipeline pipeline)
{
// Call Init to trigger any custom initialization needed after
// module load and before pipeline is setup and used.
Init();
pipeline = new Runtime.HttpPipeline(new Runtime.HttpClientFactory(HttpHelpers.GetGraphHttpClient()));
}
internal static TerminatingErrorTracker GetTracker(InvocationInfo invocationInfo)
{
TerminatingErrorTracker tracker;
bool foundTracker = s_invocationToTracker.TryGetValue(invocationInfo, out tracker);
Dbg.Assert(foundTracker, "The other overload of GetTracker should always be called first");
return tracker;
}
internal void InternalDispose(bool isDisposing)
{
this.myInvocation = null;
this.state = null;
this.commandInfo = null;
this.context = null;
}
/// <summary>
/// Instantiates a new instance of the CmdletInvocationException class
/// </summary>
/// <param name="innerException">wrapped exception</param>
/// <param name="invocationInfo">
/// identity of cmdlet, null is unknown
/// </param>
internal CmdletInvocationException(Exception innerException,
InvocationInfo invocationInfo)
: base(RetrieveMessage(innerException), innerException)
{
if (null == innerException)
{
throw new ArgumentNullException("innerException");
}
// invocationInfo may be null
IContainsErrorRecord icer = innerException as IContainsErrorRecord;
if (null != icer && null != icer.ErrorRecord)
{
_errorRecord = new ErrorRecord(icer.ErrorRecord, innerException);
}
else
{
// When no ErrorId is specified by a thrown exception,
// we use innerException.GetType().FullName.
_errorRecord = new ErrorRecord(
innerException,
innerException.GetType().FullName,
ErrorCategory.NotSpecified,
null);
}
_errorRecord.SetInvocationInfo(invocationInfo);
// 2005/04/13-JonN Can't do this in an unsealed class: HelpLink = innerException.HelpLink;
// Exception.Source is set by Throw
// Source = innerException.Source;
}
internal static TerminatingErrorTracker GetTracker(InvocationInfo invocationInfo, bool isStaticCmdlet)
{
var tracker = s_invocationToTracker.GetValue(
invocationInfo,
_ => new TerminatingErrorTracker(GetNumberOfSessions(invocationInfo)));
return tracker;
}
internal ActionPreferenceStopException(InvocationInfo invocationInfo, System.Management.Automation.ErrorRecord errorRecord, string baseName, string resourceId, params object[] args) : this(invocationInfo, baseName, resourceId, args)
{
if (errorRecord == null)
{
throw new ArgumentNullException("errorRecord");
}
this._errorRecord = errorRecord;
}
internal CmdletProviderInvocationException(System.Management.Automation.ProviderInvocationException innerException, InvocationInfo myInvocation) : base(GetInnerException(innerException), myInvocation)
{
if (innerException == null)
{
throw new ArgumentNullException("innerException");
}
this._providerInvocationException = innerException;
}
internal ParameterBindingValidationException(Exception innerException, ErrorCategory errorCategory, InvocationInfo invocationInfo, IScriptExtent errorPosition, string parameterName, Type parameterType, Type typeSpecified, string resourceBaseName, string errorIdAndResourceId, params object[] args) : base(innerException, errorCategory, invocationInfo, errorPosition, parameterName, parameterType, typeSpecified, resourceBaseName, errorIdAndResourceId, args)
{
ValidationMetadataException exception = innerException as ValidationMetadataException;
if ((exception != null) && exception.SwallowException)
{
this._swallowException = true;
}
}
/// <summary>
/// Constructor.
/// </summary>
/// <param name="invocationInfo"></param>
/// <param name="breakpoints"></param>
/// <param name="resumeAction"></param>
public DebuggerStopEventArgs(
InvocationInfo invocationInfo,
Collection<Breakpoint> breakpoints,
DebuggerResumeAction resumeAction)
{
this.InvocationInfo = invocationInfo;
this.Breakpoints = new ReadOnlyCollection<Breakpoint>(breakpoints);
this.ResumeAction = resumeAction;
}
/// <summary>
/// Constructs a parameter binder controller for the specified command
/// in the specified engine context.
/// </summary>
///
/// <param name="invocationInfo">
/// The invocation information about the code being run.
/// </param>
/// <param name="context">
/// The engine context in which the command is being run.
/// </param>
/// <param name="parameterBinder">
/// The default parameter binder for the command.
/// </param>
internal ParameterBinderController(InvocationInfo invocationInfo, ExecutionContext context, ParameterBinderBase parameterBinder)
{
Diagnostics.Assert(invocationInfo != null, "Caller to verify invocationInfo is not null.");
Diagnostics.Assert(parameterBinder != null, "Caller to verify parameterBinder is not null.");
Diagnostics.Assert(context != null, "call to verify context is not null.");
this.DefaultParameterBinder = parameterBinder;
Context = context;
InvocationInfo = invocationInfo;
}
/// <summary>
/// Constructs a ScriptParameterBinder with the specified context
/// </summary>
///
/// <param name="script">
/// The script block representing the code being run
/// </param>
///
/// <param name="invocationInfo">
/// The invocation information about the code that is being run.
/// </param>
///
/// <param name="context">
/// The context under which the shell function is executing.
/// </param>
///
/// <param name="command">
/// The command instance that represents the script in a pipeline. May be null.
/// </param>
///
/// <param name="localScope">
/// If binding in a new local scope, the scope to set variables in. If dotting, the value is null.
/// </param>
internal ScriptParameterBinder(
ScriptBlock script,
InvocationInfo invocationInfo,
ExecutionContext context,
InternalCommand command,
SessionStateScope localScope) : base(invocationInfo, context, command)
{
Diagnostics.Assert(script != null, "caller to verify script is not null.");
this.Script = script;
this.LocalScope = localScope;
}
internal bool Trigger(InvocationInfo invocationInfo)
{
if (!this.CommandPattern.IsMatch(invocationInfo.InvocationName) && !this.CommandInfoMatches(invocationInfo.MyCommand))
{
return false;
}
if (base.Script != null)
{
return base.Script.Equals(invocationInfo.ScriptName, StringComparison.OrdinalIgnoreCase);
}
return true;
}
internal ScriptParameterBinderController(ScriptBlock script, InvocationInfo invocationInfo, ExecutionContext context, InternalCommand command, SessionStateScope localScope) : base(invocationInfo, context, new ScriptParameterBinder(script, invocationInfo, context, command, localScope))
{
this.DollarArgs = new List<object>();
if (script.HasDynamicParameters)
{
base.UnboundParameters = base.BindableParameters.ReplaceMetadata(script.ParameterMetadata);
}
else
{
base._bindableParameters = script.ParameterMetadata;
base.UnboundParameters = new List<MergedCompiledCommandParameter>(base._bindableParameters.BindableParameters.Values);
}
}
internal RuntimeException(ErrorCategory errorCategory, InvocationInfo invocationInfo, IScriptExtent errorPosition, string errorIdAndResourceId, string message, Exception innerException) : base(message, innerException)
{
this._errorId = "RuntimeException";
this.SetErrorCategory(errorCategory);
this.SetErrorId(errorIdAndResourceId);
if ((errorPosition == null) && (invocationInfo != null))
{
errorPosition = invocationInfo.ScriptPosition;
}
if (invocationInfo != null)
{
this._errorRecord = new System.Management.Automation.ErrorRecord(new ParentContainsErrorRecordException(this), this._errorId, this._errorCategory, this._targetObject);
this._errorRecord.SetInvocationInfo(new InvocationInfo(invocationInfo.MyCommand, errorPosition));
}
}
partial void BeforeCreatePipeline(System.Management.Automation.InvocationInfo invocationInfo, ref Runtime.HttpPipeline pipeline)
{
using (var powershell = PowerShell.Create(RunspaceMode.CurrentRunspace))
{
powershell.Commands.AddCommand(new Command($"$executioncontext.SessionState.PSVariable.GetValue('{Constants.GraphAuthConfigId}')", true));
AuthConfig authConfig = powershell.Invoke <AuthConfig>().FirstOrDefault();
if (authConfig == null)
{
throw new Exception("Authentication needed, call Connect-Graph.");
}
pipeline = new Runtime.HttpPipeline(new Runtime.HttpClientFactory(HttpHelpers.GetGraphHttpClient(authConfig)));
}
}
internal ParameterBindingException(Exception innerException, ParameterBindingException pbex, string resourceBaseName, string resourceId, params object[] args) : base(string.Empty, innerException)
{
this.parameterName = string.Empty;
this.line = -9223372036854775808L;
this.offset = -9223372036854775808L;
this.args = new object[0];
if (pbex == null)
{
throw PSTraceSource.NewArgumentNullException("pbex");
}
if (string.IsNullOrEmpty(resourceBaseName))
{
throw PSTraceSource.NewArgumentException("resourceBaseName");
}
if (string.IsNullOrEmpty(resourceId))
{
throw PSTraceSource.NewArgumentException("resourceId");
}
this.invocationInfo = pbex.CommandInvocation;
if (this.invocationInfo != null)
{
this.commandName = this.invocationInfo.MyCommand.Name;
}
IScriptExtent scriptPosition = null;
if (this.invocationInfo != null)
{
scriptPosition = this.invocationInfo.ScriptPosition;
}
this.line = pbex.Line;
this.offset = pbex.Offset;
this.parameterName = pbex.ParameterName;
this.parameterType = pbex.ParameterType;
this.typeSpecified = pbex.TypeSpecified;
this.errorId = pbex.ErrorId;
this.resourceBaseName = resourceBaseName;
this.resourceId = resourceId;
if (args != null)
{
this.args = args;
}
base.SetErrorCategory(pbex.ErrorRecord._category);
base.SetErrorId(this.errorId);
if (this.invocationInfo != null)
{
base.ErrorRecord.SetInvocationInfo(new InvocationInfo(this.invocationInfo.MyCommand, scriptPosition));
}
}
internal ScriptWriter(TextReader cmdletizationXmlReader, string moduleName, string defaultObjectModelWrapper, InvocationInfo invocationInfo, GenerationOptions generationOptions)
{
XmlReader xmlReader = XmlReader.Create(cmdletizationXmlReader, xmlReaderSettings);
try
{
XmlSerializer serializer = new PowerShellMetadataSerializer();
this.cmdletizationMetadata = (PowerShellMetadata) serializer.Deserialize(xmlReader);
}
catch (InvalidOperationException exception)
{
XmlSchemaException innerException = exception.InnerException as XmlSchemaException;
if (innerException != null)
{
throw new XmlException(innerException.Message, innerException, innerException.LineNumber, innerException.LinePosition);
}
XmlException exception3 = exception.InnerException as XmlException;
if (exception3 != null)
{
throw exception3;
}
if (exception.InnerException != null)
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, CmdletizationCoreResources.ScriptWriter_ConcatenationOfDeserializationExceptions, new object[] { exception.Message, exception.InnerException.Message }), exception.InnerException);
}
throw;
}
string valueToConvert = this.cmdletizationMetadata.Class.CmdletAdapter ?? defaultObjectModelWrapper;
this.objectModelWrapper = (Type) LanguagePrimitives.ConvertTo(valueToConvert, typeof(Type), CultureInfo.InvariantCulture);
if (this.objectModelWrapper.IsGenericType)
{
throw new XmlException(string.Format(CultureInfo.CurrentCulture, CmdletizationCoreResources.ScriptWriter_ObjectModelWrapperIsStillGeneric, new object[] { valueToConvert }));
}
Type objectModelWrapper = this.objectModelWrapper;
while (!objectModelWrapper.IsGenericType || (objectModelWrapper.GetGenericTypeDefinition() != typeof(CmdletAdapter<>)))
{
objectModelWrapper = objectModelWrapper.BaseType;
if (objectModelWrapper.Equals(typeof(object)))
{
throw new XmlException(string.Format(CultureInfo.CurrentCulture, CmdletizationCoreResources.ScriptWriter_ObjectModelWrapperNotDerivedFromObjectModelWrapper, new object[] { valueToConvert, typeof(CmdletAdapter<>).FullName }));
}
}
this.objectInstanceType = objectModelWrapper.GetGenericArguments()[0];
this.moduleName = moduleName;
this.invocationInfo = invocationInfo;
this.generationOptions = generationOptions;
}
internal CmdletInvocationException(Exception innerException, InvocationInfo invocationInfo) : base(RuntimeException.RetrieveMessage(innerException), innerException)
{
if (innerException == null)
{
throw new ArgumentNullException("innerException");
}
IContainsErrorRecord record = innerException as IContainsErrorRecord;
if ((record != null) && (record.ErrorRecord != null))
{
this._errorRecord = new System.Management.Automation.ErrorRecord(record.ErrorRecord, innerException);
}
else
{
this._errorRecord = new System.Management.Automation.ErrorRecord(innerException, innerException.GetType().FullName, ErrorCategory.NotSpecified, null);
}
this._errorRecord.SetInvocationInfo(invocationInfo);
}
/// <summary>
/// Creates an InformationalRecord object from a record serialized as a PSObject by ToPSObjectForRemoting.
/// </summary>
internal InformationalRecord(PSObject serializedObject)
{
_message = (string)SerializationUtilities.GetPropertyValue(serializedObject, "InformationalRecord_Message");
_serializeExtendedInfo = (bool)SerializationUtilities.GetPropertyValue(serializedObject, "InformationalRecord_SerializeInvocationInfo");
if (_serializeExtendedInfo)
{
_invocationInfo = new InvocationInfo(serializedObject);
ArrayList pipelineIterationInfo = (ArrayList)SerializationUtilities.GetPsObjectPropertyBaseObject(serializedObject, "InformationalRecord_PipelineIterationInfo");
_pipelineIterationInfo = new ReadOnlyCollection<int>((int[])pipelineIterationInfo.ToArray(typeof(int)));
}
else
{
_invocationInfo = null;
}
}
private static int GetNumberOfSessions(InvocationInfo invocationInfo)
{
// if user explicitly specifies CimSession, then the cmdlet runs against exactly those sessions
object cimSessionArgument;
if (invocationInfo.BoundParameters.TryGetValue("CimSession", out cimSessionArgument))
{
IList cimSessionArgumentAsList = (IList)cimSessionArgument;
return cimSessionArgumentAsList.Count;
}
// else - either CimSession=localhost OR CimSession is based on CimInstance->CimSession affinity
// CimInstance->CimSession affinity in instance cmdlets can come from:
// 1. InputObject (either passed through pipeline or explicitly bound to the parameter)
// 2. AssociatedObject (either passed through pipeline or explicitly bound to the parameter [we don't know the name of the parameter though])
// CimInstance->CimSession affinity in static cmdlets can come from:
// 1. Any method argument that is either a CimInstance or CimInstance[]
// Additionally in both instance and static cmdlets, if the pipeline object is a CimInstance, then it can affect the session acted against
if (invocationInfo.ExpectingInput)
{
// can get unlimited number of CimInstances through pipeline
// - this translates into potentially unlimited number of CimSession we will work with
return int.MaxValue;
}
int maxNumberOfSessionsIndicatedByCimInstanceArguments = 1;
foreach (object cmdletArgument in invocationInfo.BoundParameters.Values)
{
CimInstance[] array = cmdletArgument as CimInstance[];
if (array != null)
{
int numberOfSessionsAssociatedWithArgument = array
.Select(CimCmdletAdapter.GetSessionOfOriginFromCimInstance)
.Distinct()
.Count();
maxNumberOfSessionsIndicatedByCimInstanceArguments = Math.Max(
maxNumberOfSessionsIndicatedByCimInstanceArguments,
numberOfSessionsAssociatedWithArgument);
}
}
return maxNumberOfSessionsIndicatedByCimInstanceArguments;
}
/// <summary>
/// Initializes the cmdlet parameter binder controller for
/// the specified cmdlet and engine context
/// </summary>
///
/// <param name="script">
/// The script that contains the parameter metadata.
/// </param>
/// <param name="invocationInfo">
/// The invocation information about the code being run.
/// </param>
/// <param name="context">
/// The engine context the cmdlet is run in.
/// </param>
/// <param name="command">
/// The command that the parameters will be bound to.
/// </param>
/// <param name="localScope">
/// The scope that the parameter binder will use to set parameters.
/// </param>
internal ScriptParameterBinderController(
ScriptBlock script,
InvocationInfo invocationInfo,
ExecutionContext context,
InternalCommand command,
SessionStateScope localScope)
: base(invocationInfo, context, new ScriptParameterBinder(script, invocationInfo, context, command, localScope))
{
this.DollarArgs = new List<object>();
// Add the script parameter metadata to the bindable parameters
// And add them to the unbound parameters list
if (script.HasDynamicParameters)
{
UnboundParameters = this.BindableParameters.ReplaceMetadata(script.ParameterMetadata);
}
else
{
_bindableParameters = script.ParameterMetadata;
UnboundParameters = new List<MergedCompiledCommandParameter>(_bindableParameters.BindableParameters.Values);
}
}
public DefaultPowershellCommandInvoker(CommandInvocationIntrinsics invokeCommand, InvocationInfo myInvocation)
{
_invokeCommand = invokeCommand;
_myInvocation = myInvocation;
}
/// <summary>
/// Instantiates a new instance of the ActionPreferenceStopException class
/// </summary>
/// <param name="invocationInfo"> </param>
/// <param name="message"> </param>
/// <returns> constructed object </returns>
internal ActionPreferenceStopException(InvocationInfo invocationInfo, string message)
: this(message)
{
base.ErrorRecord.SetInvocationInfo(invocationInfo);
}
public static string GetScriptName(InvocationInfo iInfo)
{
string result = string.Empty;
try{
result =
iInfo.ScriptName;
}
catch {
return result;
}
return result;
}
public static int GetPipelinePosition(InvocationInfo iInfo)
{
int result = 0;
try{
result =
iInfo.PipelinePosition;
}
catch {
}
return result;
}
internal PSDebugContext(InvocationInfo invocationInfo, List <Breakpoint> breakpoints)
{
this.invocationInfo = invocationInfo;
this.breakpoints = breakpoints.ToArray();
}
/// <summary>
/// Generate LogContext structure based on executionContext and invocationInfo passed in.
///
/// LogContext structure is used in log provider interface.
/// </summary>
/// <param name="executionContext"></param>
/// <param name="invocationInfo"></param>
/// <returns></returns>
internal static LogContext GetLogContext(ExecutionContext executionContext, InvocationInfo invocationInfo)
{
return GetLogContext(executionContext, invocationInfo, Severity.Informational);
}
/// <summary>
/// LogPipelineExecutionDetailEvent: Log a pipeline execution detail event.
///
/// </summary>
/// <param name="executionContext">Execution Context for the current running engine</param>
/// <param name="detail">detail to be logged for this pipeline execution detail</param>
/// <param name="invocationInfo">invocation data for current command that is running</param>
internal static void LogPipelineExecutionDetailEvent(ExecutionContext executionContext,
List<String> detail,
InvocationInfo invocationInfo)
{
if (executionContext == null)
{
PSTraceSource.NewArgumentNullException("executionContext");
return;
}
foreach (LogProvider provider in GetLogProvider(executionContext))
{
if (NeedToLogPipelineExecutionDetailEvent(provider, executionContext))
{
provider.LogPipelineExecutionDetailEvent(GetLogContext(executionContext, invocationInfo), detail);
}
}
}
/// <summary>
/// Gets the parameters by matching its name.
/// </summary>
///
/// <param name="name">
/// The name of the parameter.
/// </param>
///
/// <param name="throwOnParameterNotFound">
/// If true and a matching parameter is not found, an exception will be
/// throw. If false and a matching parameter is not found, null is returned.
/// </param>
///
/// <param name="tryExactMatching">
/// If true we do exact matching, otherwise we do not.
/// </param>
///
/// <param name="invocationInfo">
/// The invocation information about the code being run.
/// </param>
///
/// <returns>
/// The a collection of the metadata associated with the parameters that
/// match the specified name. If no matches were found, an empty collection
/// is returned.
/// </returns>
///
/// <exception cref="ArgumentException">
/// If <paramref name="name"/> is null or empty.
/// </exception>
///
internal MergedCompiledCommandParameter GetMatchingParameter(
string name,
bool throwOnParameterNotFound,
bool tryExactMatching,
InvocationInfo invocationInfo)
{
if (string.IsNullOrEmpty(name))
{
throw PSTraceSource.NewArgumentException("name");
}
Collection <MergedCompiledCommandParameter> matchingParameters =
new Collection <MergedCompiledCommandParameter>();
// Skip the leading '-' if present
if (name.Length > 0 && SpecialCharacters.IsDash(name[0]))
{
name = name.Substring(1);
}
// First try to match the bindable parameters
foreach (string parameterName in _bindableParameters.Keys)
{
if (CultureInfo.InvariantCulture.CompareInfo.IsPrefix(parameterName, name, CompareOptions.IgnoreCase))
{
// If it is an exact match then only return the exact match
// as the result
if (tryExactMatching && String.Equals(parameterName, name, StringComparison.OrdinalIgnoreCase))
{
return(_bindableParameters[parameterName]);
}
else
{
matchingParameters.Add(_bindableParameters[parameterName]);
}
}
}
// Now check the aliases
foreach (string parameterName in _aliasedParameters.Keys)
{
if (CultureInfo.InvariantCulture.CompareInfo.IsPrefix(parameterName, name, CompareOptions.IgnoreCase))
{
// If it is an exact match then only return the exact match
// as the result
if (tryExactMatching && String.Equals(parameterName, name, StringComparison.OrdinalIgnoreCase))
{
return(_aliasedParameters[parameterName]);
}
else
{
if (!matchingParameters.Contains(_aliasedParameters[parameterName]))
{
matchingParameters.Add(_aliasedParameters[parameterName]);
}
}
}
}
if (matchingParameters.Count > 1)
{
// Prefer parameters in the cmdlet over common parameters
Collection <MergedCompiledCommandParameter> filteredParameters =
new Collection <MergedCompiledCommandParameter>();
foreach (MergedCompiledCommandParameter matchingParameter in matchingParameters)
{
if ((matchingParameter.BinderAssociation == ParameterBinderAssociation.DeclaredFormalParameters) ||
(matchingParameter.BinderAssociation == ParameterBinderAssociation.DynamicParameters))
{
filteredParameters.Add(matchingParameter);
}
}
if (filteredParameters.Count == 1)
{
matchingParameters = filteredParameters;
}
else
{
StringBuilder possibleMatches = new StringBuilder();
foreach (MergedCompiledCommandParameter matchingParameter in matchingParameters)
{
possibleMatches.Append(" -");
possibleMatches.Append(matchingParameter.Parameter.Name);
}
ParameterBindingException exception =
new ParameterBindingException(
ErrorCategory.InvalidArgument,
invocationInfo,
null,
name,
null,
null,
ParameterBinderStrings.AmbiguousParameter,
"AmbiguousParameter",
possibleMatches);
throw exception;
}
}
else if (matchingParameters.Count == 0)
{
if (throwOnParameterNotFound)
{
ParameterBindingException exception =
new ParameterBindingException(
ErrorCategory.InvalidArgument,
invocationInfo,
null,
name,
null,
null,
ParameterBinderStrings.NamedParameterNotFound,
"NamedParameterNotFound");
throw exception;
}
}
MergedCompiledCommandParameter result = null;
if (matchingParameters.Count > 0)
{
result = matchingParameters[0];
}
return(result);
} // GetMatchingParameter
/// <summary>
/// Generate LogContext structure based on executionContext and invocationInfo passed in.
///
/// LogContext structure is used in log provider interface.
/// </summary>
/// <param name="executionContext"></param>
/// <param name="invocationInfo"></param>
/// <returns></returns>
internal static LogContext GetLogContext(ExecutionContext executionContext, InvocationInfo invocationInfo)
{
return(GetLogContext(executionContext, invocationInfo, Severity.Informational));
}
private static bool IsGetPsCallStackCmdlet(InvocationInfo invocationInfo) => invocationInfo.ScriptLineNumber == 0 && invocationInfo.MyCommand != null && (invocationInfo.MyCommand.Context != null && invocationInfo.MyCommand.Context.CurrentCommandProcessor != null) && invocationInfo.MyCommand.Context.CurrentCommandProcessor.Command != null && invocationInfo.MyCommand.Context.CurrentCommandProcessor.Command.GetType().FullName == "Microsoft.PowerShell.Commands.GetPSCallStackCommand";
/// <summary>
/// Generate LogContext structure based on executionContext and invocationInfo passed in.
///
/// LogContext structure is used in log provider interface.
/// </summary>
/// <param name="executionContext"></param>
/// <param name="invocationInfo"></param>
/// <param name="severity"></param>
/// <returns></returns>
private static LogContext GetLogContext(ExecutionContext executionContext, InvocationInfo invocationInfo, Severity severity)
{
if (executionContext == null)
{
return(null);
}
LogContext logContext = new LogContext();
string shellId = executionContext.ShellID;
logContext.ExecutionContext = executionContext;
logContext.ShellId = shellId;
logContext.Severity = severity.ToString();
if (executionContext.EngineHostInterface != null)
{
logContext.HostName = executionContext.EngineHostInterface.Name;
logContext.HostVersion = executionContext.EngineHostInterface.Version.ToString();
logContext.HostId = (string)executionContext.EngineHostInterface.InstanceId.ToString();
}
logContext.HostApplication = string.Join(" ", Environment.GetCommandLineArgs());
if (executionContext.CurrentRunspace != null)
{
logContext.EngineVersion = executionContext.CurrentRunspace.Version.ToString();
logContext.RunspaceId = executionContext.CurrentRunspace.InstanceId.ToString();
Pipeline currentPipeline = ((RunspaceBase)executionContext.CurrentRunspace).GetCurrentlyRunningPipeline();
if (currentPipeline != null)
{
logContext.PipelineId = currentPipeline.InstanceId.ToString(CultureInfo.CurrentCulture);
}
}
logContext.SequenceNumber = NextSequenceNumber;
try
{
if (executionContext.LogContextCache.User == null)
{
logContext.User = Environment.UserDomainName + "\\" + Environment.UserName;
executionContext.LogContextCache.User = logContext.User;
}
else
{
logContext.User = executionContext.LogContextCache.User;
}
}
catch (InvalidOperationException)
{
logContext.User = Logging.UnknownUserName;
}
System.Management.Automation.Remoting.PSSenderInfo psSenderInfo =
executionContext.SessionState.PSVariable.GetValue("PSSenderInfo") as System.Management.Automation.Remoting.PSSenderInfo;
if (psSenderInfo != null)
{
logContext.ConnectedUser = psSenderInfo.UserInfo.Identity.Name;
}
logContext.Time = DateTime.Now.ToString(CultureInfo.CurrentCulture);
if (invocationInfo == null)
{
return(logContext);
}
logContext.ScriptName = invocationInfo.ScriptName;
logContext.CommandLine = invocationInfo.Line;
if (invocationInfo.MyCommand != null)
{
logContext.CommandName = invocationInfo.MyCommand.Name;
logContext.CommandType = invocationInfo.MyCommand.CommandType.ToString();
switch (invocationInfo.MyCommand.CommandType)
{
case CommandTypes.Application:
logContext.CommandPath = ((ApplicationInfo)invocationInfo.MyCommand).Path;
break;
case CommandTypes.ExternalScript:
logContext.CommandPath = ((ExternalScriptInfo)invocationInfo.MyCommand).Path;
break;
}
}
return(logContext);
}
/// <summary>
/// LogEngineLifecycleEvent: Log an engine lifecycle event.
///
/// This is the basic form of EngineLifecycleEvent logging api, in which all parameters are provided.
///
/// Variant form of this function is defined below, which will make parameter additionalInfo
/// optional.
/// </summary>
/// <param name="executionContext">execution context for current engine instance</param>
/// <param name="engineState">new engine state</param>
/// <param name="invocationInfo">invocationInfo for current command that is running</param>
internal static void LogEngineLifecycleEvent(ExecutionContext executionContext,
EngineState engineState,
InvocationInfo invocationInfo)
{
if (executionContext == null)
{
PSTraceSource.NewArgumentNullException("executionContext");
return;
}
EngineState previousState = GetEngineState(executionContext);
if (engineState == previousState)
return;
foreach (LogProvider provider in GetLogProvider(executionContext))
{
if (NeedToLogEngineLifecycleEvent(provider, executionContext))
{
provider.LogEngineLifecycleEvent(GetLogContext(executionContext, invocationInfo), engineState, previousState);
}
}
SetEngineState(executionContext, engineState);
}
/// <summary>
/// LogCommandLifecycleEvent: Log a command lifecycle event.
///
/// This is the only form of CommandLifecycleEvent logging api.
/// </summary>
/// <param name="executionContext">Execution Context for the current running engine</param>
/// <param name="commandState">new command state</param>
/// <param name="invocationInfo">invocation data for current command that is running</param>
internal static void LogCommandLifecycleEvent(ExecutionContext executionContext,
CommandState commandState,
InvocationInfo invocationInfo)
{
if (executionContext == null)
{
PSTraceSource.NewArgumentNullException("executionContext");
return;
}
if (invocationInfo == null)
{
PSTraceSource.NewArgumentNullException("invocationInfo");
return;
}
if (s_ignoredCommands.Contains(invocationInfo.MyCommand.Name))
{
return;
}
LogContext logContext = null;
foreach (LogProvider provider in GetLogProvider(executionContext))
{
if (NeedToLogCommandLifecycleEvent(provider, executionContext))
{
provider.LogCommandLifecycleEvent(
() => logContext ?? (logContext = GetLogContext(executionContext, invocationInfo)), commandState);
}
}
}
internal ActionPreferenceStopException(InvocationInfo invocationInfo, string baseName, string resourceId, params object[] args) : this(ResourceManagerCache.FormatResourceString(Assembly.GetCallingAssembly(), baseName, resourceId, args))
{
this.ErrorRecord.SetInvocationInfo(invocationInfo);
}
/// <summary>
/// LogSettingsEvent: Log a settings event
///
/// This is the basic form of LoggingSettingsEvent API. Variation of this function defined
/// below will make parameter invocationInfo optional.
/// </summary>
/// <param name="executionContext">Execution context for current running engine</param>
/// <param name="variableName">Variable name</param>
/// <param name="newValue">New value for the variable</param>
/// <param name="previousValue">Previous value for the variable</param>
/// <param name="invocationInfo">Invocation data for the command that is currently running</param>
internal static void LogSettingsEvent(ExecutionContext executionContext,
string variableName,
string newValue,
string previousValue,
InvocationInfo invocationInfo)
{
if (executionContext == null)
{
PSTraceSource.NewArgumentNullException("executionContext");
return;
}
foreach (LogProvider provider in GetLogProvider(executionContext))
{
if (NeedToLogSettingsEvent(provider, executionContext))
{
provider.LogSettingsEvent(GetLogContext(executionContext, invocationInfo), variableName, newValue, previousValue);
}
}
}
partial void BeforeCreatePipeline(System.Management.Automation.InvocationInfo invocationInfo, ref Runtime.HttpPipeline pipeline)
{
pipeline = new Runtime.HttpPipeline(new Runtime.HttpClientFactory(HttpHelpers.GetGraphHttpClient()));
}
/// <summary>
/// Generate LogContext structure based on executionContext and invocationInfo passed in.
///
/// LogContext structure is used in log provider interface.
/// </summary>
/// <param name="executionContext"></param>
/// <param name="invocationInfo"></param>
/// <param name="severity"></param>
/// <returns></returns>
private static LogContext GetLogContext(ExecutionContext executionContext, InvocationInfo invocationInfo, Severity severity)
{
if (executionContext == null)
return null;
LogContext logContext = new LogContext();
string shellId = executionContext.ShellID;
logContext.ExecutionContext = executionContext;
logContext.ShellId = shellId;
logContext.Severity = severity.ToString();
if (executionContext.EngineHostInterface != null)
{
logContext.HostName = executionContext.EngineHostInterface.Name;
logContext.HostVersion = executionContext.EngineHostInterface.Version.ToString();
logContext.HostId = (string)executionContext.EngineHostInterface.InstanceId.ToString();
}
logContext.HostApplication = String.Join(" ", Environment.GetCommandLineArgs());
if (executionContext.CurrentRunspace != null)
{
logContext.EngineVersion = executionContext.CurrentRunspace.Version.ToString();
logContext.RunspaceId = executionContext.CurrentRunspace.InstanceId.ToString();
Pipeline currentPipeline = ((RunspaceBase)executionContext.CurrentRunspace).GetCurrentlyRunningPipeline();
if (currentPipeline != null)
{
logContext.PipelineId = currentPipeline.InstanceId.ToString(CultureInfo.CurrentCulture);
}
}
logContext.SequenceNumber = NextSequenceNumber;
try
{
if (executionContext.LogContextCache.User == null)
{
logContext.User = Environment.UserDomainName + "\\" + Environment.UserName;
executionContext.LogContextCache.User = logContext.User;
}
else
{
logContext.User = executionContext.LogContextCache.User;
}
}
catch (InvalidOperationException)
{
logContext.User = Logging.UnknownUserName;
}
System.Management.Automation.Remoting.PSSenderInfo psSenderInfo =
executionContext.SessionState.PSVariable.GetValue("PSSenderInfo") as System.Management.Automation.Remoting.PSSenderInfo;
if (psSenderInfo != null)
{
logContext.ConnectedUser = psSenderInfo.UserInfo.Identity.Name;
}
logContext.Time = DateTime.Now.ToString(CultureInfo.CurrentCulture);
if (invocationInfo == null)
return logContext;
logContext.ScriptName = invocationInfo.ScriptName;
logContext.CommandLine = invocationInfo.Line;
if (invocationInfo.MyCommand != null)
{
logContext.CommandName = invocationInfo.MyCommand.Name;
logContext.CommandType = invocationInfo.MyCommand.CommandType.ToString();
switch (invocationInfo.MyCommand.CommandType)
{
case CommandTypes.Application:
logContext.CommandPath = ((ApplicationInfo)invocationInfo.MyCommand).Path;
break;
case CommandTypes.ExternalScript:
logContext.CommandPath = ((ExternalScriptInfo)invocationInfo.MyCommand).Path;
break;
}
}
return logContext;
}
internal ParameterBindingException(Exception innerException, ErrorCategory errorCategory, InvocationInfo invocationInfo, IScriptExtent errorPosition, string parameterName, Type parameterType, Type typeSpecified, string resourceBaseName, string errorIdAndResourceId, params object[] args) : base(errorCategory, invocationInfo, errorPosition, errorIdAndResourceId, null, innerException)
{
this.parameterName = string.Empty;
this.line = -9223372036854775808L;
this.offset = -9223372036854775808L;
this.args = new object[0];
if (invocationInfo == null)
{
throw PSTraceSource.NewArgumentNullException("invocationInfo");
}
if (string.IsNullOrEmpty(resourceBaseName))
{
throw PSTraceSource.NewArgumentException("resourceBaseName");
}
if (string.IsNullOrEmpty(errorIdAndResourceId))
{
throw PSTraceSource.NewArgumentException("errorIdAndResourceId");
}
this.invocationInfo = invocationInfo;
this.commandName = invocationInfo.MyCommand.Name;
this.parameterName = parameterName;
this.parameterType = parameterType;
this.typeSpecified = typeSpecified;
if (errorPosition == null)
{
errorPosition = invocationInfo.ScriptPosition;
}
if (errorPosition != null)
{
this.line = errorPosition.StartLineNumber;
this.offset = errorPosition.StartColumnNumber;
}
this.resourceBaseName = resourceBaseName;
this.resourceId = errorIdAndResourceId;
this.errorId = errorIdAndResourceId;
if (args != null)
{
this.args = args;
}
}
// public static void CloseTestResultAsIs()
// {
//
// if (TestData.TestSuites.Count == 0) {
// TestData.InitTestData();
// }
//
// if (null != TestData.CurrentTestResult) {
// TestData.CurrentTestScenario.TestResults.Add(TestData.CurrentTestResult);
// }
//
// TestData.CurrentTestResult =
// new TestResult(
// TestData.CurrentTestScenario.Id,
// TestData.CurrentTestSuite.Id);
//
// }
// 20121224
//public static bool CloseTestResult(
public static void CloseTestResult(
string testResultName,
string testResultId,
bool testResult,
bool isKnownIssue,
InvocationInfo myInvocation,
ErrorRecord error,
string description,
// 20130322
//bool generated)
//bool generated,
TestResultOrigins origin,
bool skipAutomatic)
{
// 20121224
//bool result = false;
// if (TestData.TestSuites.Count == 0) {
// TestData.InitTestData();
// }
TMX.TestData.AddTestResult(
testResultName,
testResultId,
testResult,
isKnownIssue,
true,
myInvocation,
error,
description,
// 20130322
//generated);
// 20130626
//generated,
origin,
skipAutomatic);
// 20121224
//return result;
}
private PSModuleInfo CreateModuleImplementation(string name, string path, object moduleCode, IScriptExtent scriptPosition, SessionState ss, object privateData, out ArrayList result, params object[] arguments)
{
if (ss == null)
{
ss = new SessionState(this._context, true, true);
}
SessionStateInternal engineSessionState = this._context.EngineSessionState;
PSModuleInfo info = new PSModuleInfo(name, path, this._context, ss);
ss.Internal.Module = info;
info.PrivateData = privateData;
bool flag = false;
int newValue = 0;
try
{
ScriptBlock scriptBlock;
this._context.EngineSessionState = ss.Internal;
ExternalScriptInfo scriptCommandInfo = moduleCode as ExternalScriptInfo;
if (scriptCommandInfo != null)
{
scriptBlock = scriptCommandInfo.ScriptBlock;
this._context.Debugger.RegisterScriptFile(scriptCommandInfo);
}
else
{
scriptBlock = moduleCode as ScriptBlock;
if (scriptBlock != null)
{
PSLanguageMode?languageMode = scriptBlock.LanguageMode;
scriptBlock = scriptBlock.Clone(true);
scriptBlock.LanguageMode = languageMode;
scriptBlock.SessionState = ss;
}
else if (moduleCode is string)
{
scriptBlock = ScriptBlock.Create(this._context, (string)moduleCode);
}
}
if (scriptBlock == null)
{
throw PSTraceSource.NewInvalidOperationException();
}
scriptBlock.SessionStateInternal = ss.Internal;
InvocationInfo invocationInfo = new InvocationInfo(scriptCommandInfo, scriptPosition);
info._definitionExtent = scriptBlock.Ast.Extent;
ArrayList resultList = new ArrayList();
try
{
Pipe outputPipe = new Pipe(resultList);
scriptBlock.InvokeWithPipe(false, ScriptBlock.ErrorHandlingBehavior.WriteToCurrentErrorPipe, AutomationNull.Value, AutomationNull.Value, AutomationNull.Value, outputPipe, invocationInfo, arguments ?? new object[0]);
}
catch (ExitException exception)
{
newValue = (int)exception.Argument;
flag = true;
}
result = resultList;
}
finally
{
this._context.EngineSessionState = engineSessionState;
}
if (flag)
{
this._context.SetVariable(SpecialVariables.LastExitCodeVarPath, newValue);
}
return(info);
}
public static int GetScriptLineNumber(InvocationInfo iInfo)
{
int result = 0;
try{
result =
iInfo.ScriptLineNumber;
}
catch {
return result;
}
return result;
}
internal CmdletProviderInvocationException(System.Management.Automation.ProviderInvocationException innerException, InvocationInfo myInvocation) : base(GetInnerException(innerException), myInvocation)
{
if (innerException == null)
{
throw new ArgumentNullException("innerException");
}
this._providerInvocationException = innerException;
}
private void OnDebuggerStop(InvocationInfo invocationInfo, List <Breakpoint> breakpoints)
{
LocalRunspace currentRunspace = this._context.CurrentRunspace as LocalRunspace;
if (currentRunspace.PulsePipeline != null && currentRunspace.PulsePipeline == currentRunspace.GetCurrentlyRunningPipeline())
{
if (breakpoints.Count > 0)
{
this._context.EngineHostInterface.UI.WriteWarningLine(ResourceManagerCache.FormatResourceString("DebuggerStrings", "WarningBreakpointWillNotBeHit", (object)breakpoints[0]));
}
else
{
this._context.EngineHostInterface.UI.WriteWarningLine(new InvalidOperationException().Message);
}
}
else
{
this._steppingMode = Debugger.SteppingMode.None;
EventHandler <DebuggerStopEventArgs> debuggerStop = this.DebuggerStop;
if (debuggerStop == null)
{
return;
}
this._inBreakpoint = true;
if (invocationInfo != null)
{
this._callStack.Push(new Debugger.CallStackInfo()
{
InvocationInfo = invocationInfo
});
}
this._context.SetVariable("PSDebugContext", (object)new PSDebugContext(invocationInfo, breakpoints));
PSLanguageMode languageMode = this._context.LanguageMode;
bool flag = languageMode != PSLanguageMode.FullLanguage && this._context.UseFullLanguageModeInDebugger;
if (flag)
{
this._context.LanguageMode = PSLanguageMode.FullLanguage;
}
RunspaceAvailability runspaceAvailability = this._context.CurrentRunspace.RunspaceAvailability;
this._context.CurrentRunspace.UpdateRunspaceAvailability(this._context.CurrentRunspace.GetCurrentlyRunningPipeline() != null ? RunspaceAvailability.AvailableForNestedCommand : RunspaceAvailability.Available, true);
try
{
DebuggerStopEventArgs e = new DebuggerStopEventArgs(invocationInfo, breakpoints);
debuggerStop((object)this, e);
this.ResumeExecution(e);
}
finally
{
this._context.CurrentRunspace.UpdateRunspaceAvailability(runspaceAvailability, true);
if (flag)
{
this._context.LanguageMode = languageMode;
}
this._context.RemoveVariable("PSDebugContext");
if (invocationInfo != null)
{
this._callStack.Pop();
}
this._inBreakpoint = false;
}
}
}
/// <summary>
/// The cmdlet will call this for every event during the pipeline.
/// </summary>
/// <param name="id">a <c>string</c> containing the name of the event being raised (well-known events are in <see cref="Microsoft.Azure.Commands.Common.Events"/></param>
/// <param name="cancellationToken">a <c>CancellationToken</c> indicating if this request is being cancelled.</param>
/// <param name="getEventData">a delegate to call to get the event data for this event</param>
/// <param name="signal">a delegate to signal an event from the handler to the cmdlet.</param>
/// <param name="invocationInfo">The <see cref="System.Management.Automation.InvocationInfo" /> from the cmdlet</param>
/// <param name="parameterSetName">The <see cref="string" /> containing the name of the parameter set for this invocation (if available></param>
/// <param name="correlationId">The <see cref="string" /> containing the correlation id for the cmdlet (if available)</param>
/// <param name="processRecordId">The <see cref="string" /> containing the correlation id for the individual process record. (if available)</param>
/// <param name="exception">The <see cref="System.Exception" /> that is being thrown (if available)</param>
public async Task EventListener(string id, CancellationToken cancellationToken, GetEventData getEventData, SignalDelegate signal, System.Management.Automation.InvocationInfo invocationInfo, string parameterSetName, string correlationId, string processRecordId, System.Exception exception)
{
switch (id)
{
case Events.CmdletException:
{
var data = EventDataConverter.ConvertFrom(getEventData());
await signal("Warning", cancellationToken, () => EventHelper.CreateLogEvent($"Received Exception with message '{data?.Message}'"));
}
break;
case Events.BeforeCall:
{
var data = EventDataConverter.ConvertFrom(getEventData()); // also, we manually use our TypeConverter to return an appropriate type
await signal("Debug", cancellationToken, () => EventHelper.CreateLogEvent($"BEFORE CALL The contents are '{data?.Id}' and '{data?.Message}'"));
var request = data?.RequestMessage as HttpRequestMessage;
if (request != null)
{
// alias/casting the request message to an HttpRequestMessage is necessary so that we can
// support other protocols later on. (ie, JSONRPC, MQTT, GRPC ,AMPQ, Etc..)
// at this point, we can do with the request
request.Headers.Add("x-ms-peekaboo", "true");
await signal("Debug", cancellationToken, () => EventHelper.CreateLogEvent(GeneralUtilities.GetLog(request)));
}
}
break;
case Events.ResponseCreated:
{
// once we're sure we're handling the event, then we can retrieve the event data.
// (this ensures that we're not doing any of the work unless we really care about the event. )
var data = EventDataConverter.ConvertFrom(getEventData());
await signal("Debug", cancellationToken, () => EventHelper.CreateLogEvent($"RESPONSE CREATED The contents are '{data?.Id}' and '{data?.Message}'"));
var response = data?.ResponseMessage as HttpResponseMessage;
if (response != null)
{
await signal("Debug", cancellationToken, () => EventHelper.CreateLogEvent(GeneralUtilities.GetLog(response)));
}
}
break;
default:
// By default, just print out event details
getEventData.Print(signal, cancellationToken, "Verbose", id);
break;
}
}
