public void ScriptBlockIsImmutable(InlineScriptSource[] oldInlineScriptSources, InlineScriptSource newInlineScriptSource)
{
var old = new ScriptBlock(oldInlineScriptSources);
var @new = old.AppendScript(newInlineScriptSource);
Assert.NotSame(@new, old);
}
public void ScriptBlockAppendsScript(InlineScriptSource[] oldInlineScriptSources, InlineScriptSource newInlineScriptSource)
{
var sut = new ScriptBlock(oldInlineScriptSources)
.AppendScript(newInlineScriptSource);
var expected = oldInlineScriptSources.Concat(new[] {newInlineScriptSource});
Assert.Equal(expected, sut.Scripts);
}
public void ScriptRunnerCorrectlyConvertsMultipleScripts([Frozen] IScriptEngine engine, ScriptRunner sut, InlineScriptSource[] sources)
{
var scriptBlock = new ScriptBlock(sources);
var expected = sources.Select(s => new Script(s.Name, s.ScriptText));
sut.RunScripts(scriptBlock);
Mock.Get(engine).Verify(x => x.Execute(It.Is<IEnumerable<Script>>(actual => actual.EnumerableEquals(expected))));
}
public void RunScripts(ScriptBlock scriptBlock)
{
_scripts.Clear();
foreach (var scriptSource in scriptBlock.Scripts)
{
scriptSource.Accept(this);
}
_scriptEngine.Execute(_scripts);
}
/// <summary>
/// Processes the process phase of the cmdlet
/// </summary>
protected override void ProcessRecord()
{
#region Perform Transforms
if ((!_fromStopFunction) && (Target != null))
{
Target = ResolveTarget(Target);
}
if (!_fromStopFunction)
{
if (Exception != null)
{
Exception = ResolveException(Exception);
}
else if (ErrorRecord != null)
{
Exception tempException = null;
for (int n = 0; n < ErrorRecord.Length; n++)
{
// If both Exception and ErrorRecord are specified, override the first error record's exception.
if ((n == 0) && (Exception != null))
{
tempException = Exception;
}
else
{
tempException = ResolveException(ErrorRecord[n].Exception);
}
if (tempException != ErrorRecord[n].Exception)
{
ErrorRecord[n] = new ErrorRecord(tempException, ErrorRecord[n].FullyQualifiedErrorId, ErrorRecord[n].CategoryInfo.Category, ErrorRecord[n].TargetObject);
}
}
}
}
if (Level != MessageLevel.Warning)
{
Level = ResolveLevel(Level);
}
#endregion Perform Transforms
#region Exception Integration
/*
* While conclusive error handling must happen after message handling,
* in order to integrate the exception message into the actual message,
* it becomes necessary to first integrate the exception and error record parameters into a uniform view
*
* Note: Stop-PSFFunction never specifies this parameter, thus it is not necessary to check,
* whether this function was called from Stop-PSFFunction.
*/
if ((ErrorRecord == null) && (Exception != null))
{
ErrorRecord = new ErrorRecord[1];
ErrorRecord[0] = new ErrorRecord(Exception, String.Format("{0}_{1}", ModuleName, FunctionName), ErrorCategory.NotSpecified, Target);
}
#endregion Exception Integration
#region Error handling
if (ErrorRecord != null)
{
if (!_fromStopFunction)
{
if (EnableException)
{
foreach (ErrorRecord record in ErrorRecord)
{
WriteError(record);
}
}
}
LogHost.WriteErrorEntry(ErrorRecord, FunctionName, ModuleName, _Tags, _timestamp, _MessageSystem, System.Management.Automation.Runspaces.Runspace.DefaultRunspace.InstanceId, Environment.MachineName);
}
#endregion Error handling
LogEntryType channels = LogEntryType.None;
#region Warning handling
if (Level == MessageLevel.Warning)
{
if (!_silent)
{
if (!String.IsNullOrEmpty(Once))
{
string onceName = String.Format("MessageOnce.{0}.{1}", FunctionName, Once).ToLower();
if (!(Configuration.ConfigurationHost.Configurations.ContainsKey(onceName) && (bool)Configuration.ConfigurationHost.Configurations[onceName].Value))
{
WriteWarning(_MessageStreams);
channels = channels | LogEntryType.Warning;
Configuration.Config cfg = new Configuration.Config();
cfg.Module = "messageonce";
cfg.Name = String.Format("{0}.{1}", FunctionName, Once).ToLower();
cfg.Hidden = true;
cfg.Description = "Locking setting that disables further display of the specified message";
cfg.Value = true;
Configuration.ConfigurationHost.Configurations[onceName] = cfg;
}
}
else
{
WriteWarning(_MessageStreams);
channels = channels | LogEntryType.Warning;
}
}
WriteDebug(_MessageStreams);
channels = channels | LogEntryType.Debug;
}
#endregion Warning handling
#region Message handling
if (!_silent)
{
if ((MessageHost.MaximumInformation >= (int)Level) && (MessageHost.MinimumInformation <= (int)Level))
{
if (!String.IsNullOrEmpty(Once))
{
string onceName = String.Format("MessageOnce.{0}.{1}", FunctionName, Once).ToLower();
if (!(Configuration.ConfigurationHost.Configurations.ContainsKey(onceName) && (bool)Configuration.ConfigurationHost.Configurations[onceName].Value))
{
InvokeCommand.InvokeScript(false, ScriptBlock.Create(_writeHostScript), null, _MessageHost);
channels = channels | LogEntryType.Information;
Configuration.Config cfg = new Configuration.Config();
cfg.Module = "messageonce";
cfg.Name = String.Format("{0}.{1}", FunctionName, Once).ToLower();
cfg.Hidden = true;
cfg.Description = "Locking setting that disables further display of the specified message";
cfg.Value = true;
Configuration.ConfigurationHost.Configurations[onceName] = cfg;
}
}
else
{
//InvokeCommand.InvokeScript(_writeHostScript, _MessageHost);
InvokeCommand.InvokeScript(false, ScriptBlock.Create(_writeHostScript), null, _MessageHost);
channels = channels | LogEntryType.Information;
}
}
}
if ((MessageHost.MaximumVerbose >= (int)Level) && (MessageHost.MinimumVerbose <= (int)Level))
{
if ((_callStack.Count() > 1) && _callStack.ElementAt(_callStack.Count() - 2).InvocationInfo.BoundParameters.ContainsKey("Verbose"))
{
InvokeCommand.InvokeScript(@"$VerbosePreference = 'Continue'");
}
//SessionState.PSVariable.Set("VerbosePreference", ActionPreference.Continue);
WriteVerbose(_MessageStreams);
channels = channels | LogEntryType.Verbose;
}
if ((MessageHost.MaximumDebug >= (int)Level) && (MessageHost.MinimumDebug <= (int)Level))
{
bool restoreInquire = false;
if (_isDebug)
{
if (Breakpoint.ToBool())
{
InvokeCommand.InvokeScript(false, ScriptBlock.Create(@"$DebugPreference = 'Inquire'"), null, null);
}
else
{
InvokeCommand.InvokeScript(false, ScriptBlock.Create(@"$DebugPreference = 'Continue'"), null, null);
restoreInquire = true;
}
WriteDebug(String.Format("{0} | {1}", Line, _MessageStreams));
channels = channels | LogEntryType.Debug;
}
else
{
WriteDebug(_MessageStreams);
channels = channels | LogEntryType.Debug;
}
if (restoreInquire)
{
InvokeCommand.InvokeScript(false, ScriptBlock.Create(@"$DebugPreference = 'Inquire'"), null, null);
}
}
#endregion Message handling
#region Logging
LogEntry entry = LogHost.WriteLogEntry(_MessageSystem, channels, _timestamp, FunctionName, ModuleName, _Tags, Level, System.Management.Automation.Runspaces.Runspace.DefaultRunspace.InstanceId, Environment.MachineName, File, Line, _callStack, String.Format("{0}\\{1}", Environment.UserDomainName, Environment.UserName), Target);
#endregion Logging
foreach (MessageEventSubscription subscription in MessageHost.Events.Values)
{
if (subscription.Applies(entry))
{
try { InvokeCommand.InvokeScript(subscription.ScriptBlock.ToString(), entry); }
catch (Exception e) { WriteError(new ErrorRecord(e, "", ErrorCategory.NotSpecified, entry)); }
}
}
}
public static IEnumerable <T> RunScript <T>(this EngineIntrinsics engineIntrinsics, ScriptBlock block) => PsHelpers.RunScript <T>(engineIntrinsics.InvokeCommand, block.ToString());
public static IEnumerable <T> RunScript <T>(this PSCmdlet cmdlet, ScriptBlock block) => PsHelpers.RunScript <T>(cmdlet.InvokeCommand, block.ToString());
/// <summary>
/// Creates an instance of the ConfigurationInfo class with the specified name and ScriptBlock
/// </summary>
///
/// <param name="name">
/// The name of the configuration.
/// </param>
///
/// <param name="configuration">
/// The ScriptBlock for the configuration
/// </param>
///
/// <param name="options">
/// The options to set on the function. Note, Constant can only be set at creation time.
/// </param>
///
/// <param name="context">
/// The execution context for the configuration.
/// </param>
///
/// <param name="helpFile">
/// The help file for the configuration.
/// </param>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="configuration"/> is null.
/// </exception>
///
internal ConfigurationInfo(string name, ScriptBlock configuration, ScopedItemOptions options, ExecutionContext context, string helpFile)
: this(name, configuration, options, context, helpFile, false)
{
}
/// <summary>
/// Creates an instance of the ConfigurationInfo class with the specified name and ScriptBlock
/// </summary>
///
/// <param name="name">
/// The name of the configuration.
/// </param>
///
/// <param name="configuration">
/// The ScriptBlock for the configuration
/// </param>
///
/// <param name="context">
/// The ExecutionContext for the configuration.
/// </param>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="configuration"/> is null.
/// </exception>
///
internal ConfigurationInfo(string name, ScriptBlock configuration, ExecutionContext context) : this(name, configuration, context, null)
{
}
/// <summary>
/// Creates an instance of the ConfigurationInfo class with the specified name and ScriptBlock
/// </summary>
///
/// <param name="name">
/// The name of the configuration.
/// </param>
///
/// <param name="configuration">
/// The ScriptBlock for the configuration
/// </param>
///
/// <param name="options">
/// The options to set on the function. Note, Constant can only be set at creation time.
/// </param>
///
/// <param name="context">
/// The execution context for the configuration.
/// </param>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="configuration"/> is null.
/// </exception>
///
internal ConfigurationInfo(string name, ScriptBlock configuration, ScopedItemOptions options, ExecutionContext context) : this(name, configuration, options, context, null)
{
}
/// <summary>
/// Sets the function of the specified name to the specified value
/// </summary>
/// <param name="name">
/// The name of the function to set.
/// </param>
/// <param name="value">
/// The new value for the function.
/// </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");
FunctionProviderDynamicParameters dynamicParameters =
DynamicParameters as FunctionProviderDynamicParameters;
CommandInfo modifiedItem = null;
bool dynamicParametersSpecified = dynamicParameters != null && dynamicParameters.OptionsSet;
if (value == null)
{
// If the value wasn't specified but the options were, just set the
// options on the existing function.
// If the options weren't specified, then remove the function
if (dynamicParametersSpecified)
{
modifiedItem = (CommandInfo)GetSessionStateItem(name);
if (modifiedItem != null)
{
SetOptions(modifiedItem, dynamicParameters.Options);
}
}
else
{
RemoveSessionStateItem(name);
}
}
else
{
do // false loop
{
// Unwrap the PSObject before binding it as a scriptblock...
PSObject pso = value as PSObject;
if (pso != null)
{
value = pso.BaseObject;
}
ScriptBlock scriptBlockValue = value as ScriptBlock;
if (scriptBlockValue != null)
{
if (dynamicParametersSpecified)
{
modifiedItem = SessionState.Internal.SetFunction(name, scriptBlockValue,
null, dynamicParameters.Options, Force, Context.Origin);
}
else
{
modifiedItem = SessionState.Internal.SetFunction(name, scriptBlockValue, null, Force, Context.Origin);
}
break;
}
FunctionInfo function = value as FunctionInfo;
if (function != null)
{
ScopedItemOptions options = function.Options;
if (dynamicParametersSpecified)
{
options = dynamicParameters.Options;
}
modifiedItem = SessionState.Internal.SetFunction(name, function.ScriptBlock, function, options, Force, Context.Origin);
break;
}
string stringValue = value as string;
if (stringValue != null)
{
ScriptBlock scriptBlock = ScriptBlock.Create(Context.ExecutionContext, stringValue);
if (dynamicParametersSpecified)
{
modifiedItem = SessionState.Internal.SetFunction(name, scriptBlock, null, dynamicParameters.Options, Force, Context.Origin);
}
else
{
modifiedItem = SessionState.Internal.SetFunction(name, scriptBlock, null, Force, Context.Origin);
}
break;
}
throw PSTraceSource.NewArgumentException("value");
} while (false);
if (writeItem && modifiedItem != null)
{
WriteItemObject(modifiedItem, modifiedItem.Name, false);
}
}
}
private static bool ArbitraryFilter(NtProcess proc, ScriptBlock filter)
{
return(filter.InvokeWithArg(false, proc));
}
private static MulticastDelegate CreateDelegate(ScriptBlock scriptBlock, Closure sourceClosure, Type delegateType)
{
var sb = Expression.Constant(scriptBlock, typeof(ScriptBlock));
var sourceClosureExpr = Expression.Constant(sourceClosure, typeof(Closure));
var closure = Expression.Variable(typeof(Closure));
var invokeResult = Expression.Variable(typeof(object));
var variables = new List <ParameterExpression> {
closure, invokeResult
};
MethodInfo invokeMethod = delegateType.GetMethod(nameof(Action.Invoke));
ParameterInfo[] parameters = invokeMethod.GetParameters();
ParameterExpression[] parameterExprs;
Expression[] convertedParameters;
Type[] delegateTypes;
Type returnType = invokeMethod.ReturnType;
if (parameters.Length > 0)
{
convertedParameters = new Expression[parameters.Length];
parameterExprs = new ParameterExpression[parameters.Length];
delegateTypes = new Type[parameters.Length + 1];
for (var i = 0; i < parameters.Length; i++)
{
var parameter = Expression.Parameter(parameters[i].ParameterType, parameters[i].Name);
parameterExprs[i] = parameter;
convertedParameters[i] = Expression.Convert(parameter, typeof(object));
// Expression.Convert(
// typeof(object));
delegateTypes[i] = parameters[i].ParameterType;
}
delegateTypes[parameters.Length] = invokeMethod.ReturnType;
}
else
{
parameterExprs = Array.Empty <ParameterExpression>();
convertedParameters = Array.Empty <Expression>();
delegateTypes = new[] { invokeMethod.ReturnType };
}
var body = new List <Expression>
{
Expression.Assign(
closure,
Expression.Call(
sourceClosureExpr,
typeof(Closure).GetMethod(nameof(Closure.Clone), BindingFlags.Instance | BindingFlags.NonPublic),
Expression.NewArrayInit(typeof(object), convertedParameters))),
Expression.Assign(
invokeResult,
Expression.Call(
Expression.Field(closure, typeof(Closure).GetField(nameof(Closure.ScriptBlock))),
typeof(ScriptBlock).GetMethod(nameof(ScriptBlock.InvokeReturnAsIs)),
Expression.NewArrayInit(typeof(object), Expression.Convert(closure, typeof(object)))))
};
if (returnType == typeof(void))
{
body.Add(Expression.Empty());
}
else
{
var convertedResult = Expression.Variable(returnType);
variables.Add(convertedResult);
body.Add(
Expression.Condition(
Expression.Call(
typeof(LanguagePrimitives),
nameof(LanguagePrimitives.TryConvertTo),
new[] { returnType },
invokeResult,
convertedResult),
convertedResult,
Expression.Default(returnType)));
}
return((MulticastDelegate)Expression.Lambda(
Expression.GetDelegateType(delegateTypes),
Expression.Block(
returnType,
variables,
body),
parameterExprs)
.Compile());
}
public static Func <object, object, object, object, object, object, object, object, object, object, object, object, object, object> CreateTridecenaryFunction(ScriptBlock script)
{
return((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13) => {
return script.Invoke(null, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13);
});
}
public static Func <object> CreateNullaryFunction(ScriptBlock script)
{
return(() => {
return script.Invoke(null);
});
}
public static Func <object, object, object, object, object, object, object, object, object> CreateOctonaryFunction(ScriptBlock script)
{
return((arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8) => {
return script.Invoke(null, arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8);
});
}
public static Func <object, object, object, object, object, object> CreateQuinaryFunction(ScriptBlock script)
{
return((arg1, arg2, arg3, arg4, arg5) => {
return script.Invoke(null, arg1, arg2, arg3, arg4, arg5);
});
}
/// <summary>
/// The expression will be executed in the remote computer if a
/// remote runspace parameter or computer name is specified. If
/// none other than command parameter is specified, then it
/// just executes the command locally without creating a new
/// remote runspace object.
/// </summary>
protected override void ProcessRecord()
{
if (ParameterSetName == DefinitionNameParameterSet)
{
// Get the Job2 object from the Job Manager for this definition name and start the job.
string resolvedPath = null;
if (!string.IsNullOrEmpty(_definitionPath))
{
ProviderInfo provider = null;
System.Collections.ObjectModel.Collection <string> paths =
this.Context.SessionState.Path.GetResolvedProviderPathFromPSPath(_definitionPath, out provider);
// Only file system paths are allowed.
if (!provider.NameEquals(this.Context.ProviderNames.FileSystem))
{
string message = StringUtil.Format(RemotingErrorIdStrings.StartJobDefinitionPathInvalidNotFSProvider,
_definitionName,
_definitionPath,
provider.FullName);
WriteError(new ErrorRecord(new RuntimeException(message), "StartJobFromDefinitionNamePathInvalidNotFileSystemProvider",
ErrorCategory.InvalidArgument, null));
return;
}
// Only a single file path is allowed.
if (paths.Count != 1)
{
string message = StringUtil.Format(RemotingErrorIdStrings.StartJobDefinitionPathInvalidNotSingle,
_definitionName,
_definitionPath);
WriteError(new ErrorRecord(new RuntimeException(message), "StartJobFromDefinitionNamePathInvalidNotSingle",
ErrorCategory.InvalidArgument, null));
return;
}
resolvedPath = paths[0];
}
List <Job2> jobs = JobManager.GetJobToStart(_definitionName, resolvedPath, _definitionType, this, false);
if (jobs.Count == 0)
{
string message = (_definitionType != null) ?
StringUtil.Format(RemotingErrorIdStrings.StartJobDefinitionNotFound2, _definitionType, _definitionName) :
StringUtil.Format(RemotingErrorIdStrings.StartJobDefinitionNotFound1, _definitionName);
WriteError(new ErrorRecord(new RuntimeException(message), "StartJobFromDefinitionNameNotFound",
ErrorCategory.ObjectNotFound, null));
return;
}
if (jobs.Count > 1)
{
string message = StringUtil.Format(RemotingErrorIdStrings.StartJobManyDefNameMatches, _definitionName);
WriteError(new ErrorRecord(new RuntimeException(message), "StartJobFromDefinitionNameMoreThanOneMatch",
ErrorCategory.InvalidResult, null));
return;
}
// Start job.
Job2 job = jobs[0];
job.StartJob();
// Write job object to host.
WriteObject(job);
return;
}
if (_firstProcessRecord)
{
_firstProcessRecord = false;
PSRemotingJob job = new PSRemotingJob(ResolvedComputerNames, Operations,
ScriptBlock.ToString(), ThrottleLimit, _name);
job.PSJobTypeName = s_startJobType;
this.JobRepository.Add(job);
WriteObject(job);
}
// inject input
if (InputObject != AutomationNull.Value)
{
foreach (IThrottleOperation operation in Operations)
{
ExecutionCmdletHelper helper = (ExecutionCmdletHelper)operation;
helper.Pipeline.Input.Write(InputObject);
}
}
} // ProcessRecord
public WPFJob(string name, string command, ScriptBlock scriptBlock, InitialSessionState initalSessionState) : base(command, name)
{
this.initialSessionState = initalSessionState;
Start(scriptBlock, new Hashtable());
}
public ScriptBlock FailingScriptBlockTest(ScriptBlock scripts)
{
return scripts.AppendFile("simpleTests.js")
.AppendInlineScript("failingTest();");
}
/// <summary>
/// Adds an inline script block to the page.
/// </summary>
/// <param name="key">A unique identifier for the script block.</param>
/// <param name="script">The JavaScript code to include in the Page.</param>
public ScriptBlock Block(string key, Action script)
{
ScriptBlock block;
if (!_blocks.TryGetValue(key, out block))
{
block = new ScriptBlock(this);
_blocks[key] = block;
}
if (script != null)
block.Append(script);
return block;
}
private static ScriptBlock GetScript(string filePath)
{
var scriptText = string.Format(Resources.FileContentCompletion, filePath?.Replace("\"", "\"\""));
return(ScriptBlock.Create(scriptText));
}
} // FilterInfo ctor
/// <summary>
/// Creates an instance of the FilterInfo class with the specified name and ScriptBlock
/// </summary>
///
/// <param name="name">
/// The name of the filter.
/// </param>
///
/// <param name="filter">
/// The ScriptBlock for the filter
/// </param>
///
/// <param name="options">
/// The options to set on the function. Note, Constant can only be set at creation time.
/// </param>
///
/// <param name="context">
/// The execution context for the filter.
/// </param>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="filter"/> is null.
/// </exception>
///
internal FilterInfo(string name, ScriptBlock filter, ScopedItemOptions options, ExecutionContext context) : this(name, filter, options, context, null)
{
} // FilterInfo ctor
/// <exception cref="ParseException"></exception>
internal void VerifyScriptBlockText(string scriptText)
{
ScriptBlock.Create(scriptText);
}
private static void LoadScriptBlock(Level level, ScriptDef targetSD, XmlNode node, ScriptBlock root, string firstChildName = "")
{
if (node == null || root == null) {
return;
}
var child = node.FirstChild;
if (child == null) {
return;
}
do {
if (!firstChildName.Equals("")) {
if (!child.Name.Equals(firstChildName, StringComparison.InvariantCultureIgnoreCase)) {
Log.WriteInfo("Attention ! Impossible d'ajouter le scriptBlock : " + child.Name + " alors que le scriptBlock obligatoire est : " + firstChildName);
continue;
}
}
ScriptBlock scriptBlock = null;
switch (child.Name.ToLower()) {
case "action": {
var a = child.Attributes?["a"];
if (a == null)
throw new Exception(" le scriptBlock <action> ne contient pas d'action \"a\" !");
var p = child.Attributes?["p"];
if (p == null)
throw new Exception(" le scriptBlock <action> ne contient pas de paramètres ! \"p\" ");
var parameters = new List<string>();
var i = 1;
do {
parameters.Add(p.Value);
++i;
} while ((p = child.Attributes?["p" + i]) != null);
scriptBlock = new ScriptAction(level, a.Value, parameters);
}
break;
case "update": {
var delayA = child.Attributes?["delay"];
if (delayA == null)
throw new Exception(" le scriptBlock <update> ne contient pas de delay");
double delay = 0.0;
if (delayA.Value.Equals("$FRAME_RATE")) {
delay = 1.0 / 60.0;
}
else {
if (!double.TryParse(delayA.Value, out delay))
throw new Exception(" le scriptBlock <update> ne contient pas de delay valide !");
if (delay <= 0)
throw new Exception(" le scriptBlock <update> ne contient pas un delay valide ! Il est plus petit ou égal à 0 !");
}
scriptBlock = new ScriptUpdate(delay);
LoadScriptBlock(level, targetSD, child, scriptBlock);
}
break;
case "condition": {
var varRefA = child.Attributes?["ref"];
var valueConditionA = child.Attributes?["value"];
if (varRefA == null || valueConditionA == null)
throw new Exception(" le scriptBlock <condition> ne contient pas la référence vers la variable ou sa condition \"ref\" ou \"value\" !");
if (!targetSD.Variables.ContainsKey(varRefA.Value))
throw new Exception(" le scriptBlock <condition> utilise la variable : " + varRefA.Value + " alors qu'elle n'est pas définie dans <variables> !");
var variable = targetSD.Variables[varRefA.Value];
if (variable is int) {
if (!int.TryParse(valueConditionA.Value, out var condition)) {
throw new Exception(" dans le scriptBlock <condition>, la condition utilisée ne peut pas être convertie en nombre (int) !");
}
scriptBlock = new ScriptCondition<int>(varRefA.Value, condition);
}
else if (variable is bool) {
if (!bool.TryParse(valueConditionA.Value, out var condition)) {
throw new Exception(" dans le scriptBlock <condition>, la condition utilisée ne peut pas être convertie en booléen (bool) !");
}
scriptBlock = new ScriptCondition<bool>(varRefA.Value, condition);
}
else
throw new Exception(" le scriptBlock <condition> utilise une variable dont le type est inconnu !");
LoadScriptBlock(level, targetSD, child, scriptBlock);
}
break;
case "collision": {
var dirSide = child.Attributes?["side"];
var typeRef = child.Attributes?["typeRef"];
if (dirSide == null || typeRef == null)
throw new Exception(" le scriptBlock <collision> ne contient pas la direction \"side\" ou la référence \"typeRef\" !");
var sides = new List<PhysicsBody.CollisionSide>();
var rawSides = dirSide.Value.Split('|');
foreach (var rawSide in rawSides) {
if (!Enum.TryParse<PhysicsBody.CollisionSide>(rawSide, out var side))
throw new Exception(" le scriptBlock <collision> contient une erreur ! Impossible de convertir : " + dirSide.Value + " en direction !");
sides.Add(side);
}
scriptBlock = new ScriptCollisionEvent(sides, typeRef.Value);
LoadScriptBlock(level, targetSD, child, scriptBlock);
}
break;
case "key": {
var codeA = child.Attributes?["code"];
var justPressedA = child.Attributes?["justPressed"];
var upA = child.Attributes?["up"];
if (codeA == null)
throw new Exception(" le scriptBlock <key> ne contient pas la touche \"code\"");
if (!Enum.TryParse<Keyboard.Key>(codeA.Value, true, out var key)) {
throw new Exception(" le scriptBlock <key> contient une touche qui n'existe pas ! : " + codeA.Value);
}
bool justPressed = false, up = false;
if (justPressedA != null) {
if (!bool.TryParse(justPressedA.Value, out justPressed))
throw new Exception(" le scriptBlock <key> contient des erreurs ! Impossible de convertir : " + justPressedA.Value + " en valeur booléenne !");
}
if (upA != null) {
if (!bool.TryParse(upA.Value, out up))
throw new Exception(" le scriptBlock <key> contient des erreurs ! Impossible de convertir : " + upA.Value + " en valeur booléenne !");
}
scriptBlock = new ScriptInput(key, justPressed, up);
LoadScriptBlock(level, targetSD, child, scriptBlock);
}
break;
}
if (scriptBlock == null)
throw new Exception(" le script contient un scriptBlock inconnu !");
root.AddChild(scriptBlock);
} while ((child = child.NextSibling) != null);
}
public override void ResumeJob()
{
ScriptBlock.Create("$args[0] | Resume-PrintJob -ComputerName $args[1]").Invoke(_source, ComputerName);
}
private IEnumerable <Field> GetFieldsFromParamBlock()
{
var paramBlock = (ParamBlockAst)Endpoint.Ast.Find(m => m is ParamBlockAst, false);
var fields = new List <Field>();
if (paramBlock == null)
{
return(fields);
}
foreach (var parameter in paramBlock.Parameters)
{
var parameterAttribute = parameter.Attributes.OfType <AttributeAst>().FirstOrDefault(m => m.TypeName.Name == "Parameter");
var validateSetAttribute = parameter.Attributes.OfType <AttributeAst>().FirstOrDefault(m => m.TypeName.Name == "ValidateSet");
var stringConstant = parameterAttribute?.NamedArguments?.FirstOrDefault(m => m.ArgumentName.Equals("HelpMessage", StringComparison.OrdinalIgnoreCase))?.Argument as StringConstantExpressionAst;
var field = new Field();
if (Validate)
{
var validateErrorMessageAttribute = parameter.Attributes.OfType <AttributeAst>().FirstOrDefault(m => m.TypeName.Name.Equals("UniversalDashboard.ValidationErrorMessage", StringComparison.OrdinalIgnoreCase));
var validateErrorMessage = validateErrorMessageAttribute?.PositionalArguments.FirstOrDefault() as StringConstantExpressionAst;
var mandatoryProperty = parameterAttribute?.NamedArguments?.FirstOrDefault(m => m.ArgumentName.Equals("Mandatory", StringComparison.OrdinalIgnoreCase))?.Argument;
var isMandatory = (bool?)mandatoryProperty?.SafeGetValue() == true;
var endpoint = new Endpoint(ScriptBlock.Create($"param({parameter.ToString()})"));
endpoint.Name = Guid.NewGuid().ToString();
endpoint.SessionId = SessionId;
var hostState = this.GetHostState();
hostState.EndpointService.Register(endpoint);
field.Required = isMandatory;
field.Endpoint = endpoint;
field.ValidationEndpoint = endpoint.Name;
field.ValidationErrorMessage = validateErrorMessage?.Value;
}
var placeholder = stringConstant?.Value;
if (placeholder != null)
{
field.Placeholder = new string[] { placeholder }
}
;
field.Name = parameter.Name.VariablePath.ToString();
if (parameter.StaticType == typeof(bool) || parameter.StaticType == typeof(SwitchParameter))
{
field.Type = FieldTypes.Checkbox;
field.Value = "false";
field.DotNetType = parameter.StaticType.FullName;
}
else if (parameter.StaticType.IsEnum)
{
field.Type = FieldTypes.Select;
field.ValidOptions = Enum.GetNames(parameter.StaticType);
field.DotNetType = parameter.StaticType.FullName;
field.Value = Enum.GetValues(parameter.StaticType).GetValue(0)?.ToString();
}
else if (parameter.StaticType == typeof(DateTime))
{
field.Type = FieldTypes.Date;
field.DotNetType = parameter.StaticType.FullName;
}
else if (parameter.StaticType == typeof(SecureString))
{
field.Type = FieldTypes.Password;
field.DotNetType = parameter.StaticType.FullName;
}
else if (parameter.StaticType == typeof(String[]))
{
field.Type = FieldTypes.Textarea;
field.DotNetType = parameter.StaticType.FullName;
}
else
{
field.Type = FieldTypes.Textbox;
field.DotNetType = typeof(string).FullName;
if (validateSetAttribute != null)
{
field.ValidOptions = validateSetAttribute?.PositionalArguments.OfType <StringConstantExpressionAst>().Select(m => m.Value).ToArray();
field.Type = FieldTypes.Select;
field.Value = field.ValidOptions[0]?.ToString();
}
}
fields.Add(field);
}
return(fields);
}
public override void SuspendJob()
{
ScriptBlock.Create("$args[0] | Suspend-PrintJob -ComputerName $args[1]").Invoke(_source, ComputerName);
}
public static void RunScript(this PSCmdlet cmdlet, ScriptBlock block) => cmdlet.RunScript <PSObject>(block.ToString());
/// <summary>
///
/// </summary>
/// <param name="powerShellVersion"></param>
/// <param name="credential"></param>
/// <param name="initializationScript"></param>
/// <param name="useWow64"></param>
public PowerShellProcessInstance(Version powerShellVersion, PSCredential credential, ScriptBlock initializationScript, bool useWow64)
{
string psWow64Path = s_PSExePath;
if (useWow64)
{
string procArch = Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE");
if ((!string.IsNullOrEmpty(procArch)) && (procArch.Equals("amd64", StringComparison.OrdinalIgnoreCase) ||
procArch.Equals("ia64", StringComparison.OrdinalIgnoreCase)))
{
psWow64Path = s_PSExePath.ToLowerInvariant().Replace("\\system32\\", "\\syswow64\\");
if (!File.Exists(psWow64Path))
{
string message =
PSRemotingErrorInvariants.FormatResourceString(
RemotingErrorIdStrings.IPCWowComponentNotPresent,
psWow64Path);
throw new PSInvalidOperationException(message);
}
}
}
#if CORECLR
string processArguments = " -s -NoLogo -NoProfile";
#else
// Adding Version parameter to powershell
// Version parameter needs to go before all other parameters because the native layer looks for Version or
// PSConsoleFile parameters before parsing other parameters.
// The other parameters get parsed in the managed layer.
Version tempVersion = powerShellVersion ?? PSVersionInfo.PSVersion;
string processArguments = string.Format(CultureInfo.InvariantCulture,
"-Version {0}", new Version(tempVersion.Major, tempVersion.Minor));
processArguments = string.Format(CultureInfo.InvariantCulture,
"{0} -s -NoLogo -NoProfile", processArguments);
#endif
if (initializationScript != null)
{
string scripBlockAsString = initializationScript.ToString();
if (!string.IsNullOrEmpty(scripBlockAsString))
{
string encodedCommand =
Convert.ToBase64String(Encoding.Unicode.GetBytes(scripBlockAsString));
processArguments = string.Format(CultureInfo.InvariantCulture,
"{0} -EncodedCommand {1}", processArguments, encodedCommand);
}
}
// 'WindowStyle' is used only if 'UseShellExecute' is 'true'. Since 'UseShellExecute' is set
// to 'false' in our use, we can ignore the 'WindowStyle' setting in the initialization below.
_startInfo = new ProcessStartInfo
{
FileName = useWow64 ? psWow64Path : s_PSExePath,
Arguments = processArguments,
UseShellExecute = false,
RedirectStandardInput = true,
RedirectStandardOutput = true,
RedirectStandardError = true,
CreateNoWindow = true,
#if !UNIX
LoadUserProfile = true,
#endif
};
if (credential != null)
{
Net.NetworkCredential netCredential = credential.GetNetworkCredential();
_startInfo.UserName = netCredential.UserName;
_startInfo.Domain = string.IsNullOrEmpty(netCredential.Domain) ? "." : netCredential.Domain;
_startInfo.Password = credential.Password;
}
Process = new Process {
StartInfo = _startInfo, EnableRaisingEvents = true
};
}
public static void RunScript(this EngineIntrinsics engineIntrinsics, ScriptBlock block) => engineIntrinsics.RunScript <PSObject>(block.ToString());
/// <summary> /// Sets a command breakpoint in the debugger. /// </summary> /// <param name="command">The name of the command that will trigger the breakpoint. This value is required and may not be null.</param> /// <param name="action">The action to take when the breakpoint is hit. If null, PowerShell will break into the debugger when the breakpoint is hit.</param> /// <param name="path">The path to the script file where the breakpoint may be hit. If null, the breakpoint may be hit anywhere the command is invoked.</param> /// <param name="runspaceId">The runspace id of the runspace you want to interact with. Defaults to null (current runspace).</param> /// <returns>The command breakpoint that was set.</returns> public override CommandBreakpoint SetCommandBreakpoint(string command, ScriptBlock action = null, string path = null, int?runspaceId = null) => _wrappedDebugger.SetCommandBreakpoint(command, action, path, runspaceId);
public OnSuccessStep(string workigDirectory, ScriptBlock scriptBlock)
: base(workigDirectory, scriptBlock)
{
}
/// <summary> /// Sets a variable breakpoint in the debugger. /// </summary> /// <param name="variableName">The name of the variable that will trigger the breakpoint. This value is required and may not be null.</param> /// <param name="accessMode">The variable access mode that will trigger the breakpoint. By default variable breakpoints will trigger only when the variable is updated.</param> /// <param name="action">The action to take when the breakpoint is hit. If null, PowerShell will break into the debugger when the breakpoint is hit.</param> /// <param name="path">The path to the script file where the breakpoint may be hit. If null, the breakpoint may be hit anywhere the variable is accessed using the specified access mode.</param> /// <param name="runspaceId">The runspace id of the runspace you want to interact with. Defaults to null (current runspace).</param> /// <returns>The variable breakpoint that was set.</returns> public override VariableBreakpoint SetVariableBreakpoint(string variableName, VariableAccessMode accessMode = VariableAccessMode.Write, ScriptBlock action = null, string path = null, int?runspaceId = null) => _wrappedDebugger.SetVariableBreakpoint(variableName, accessMode, action, path, runspaceId);
public WPFJob(string name, string command, ScriptBlock scriptBlock) : base(command, name)
{
this.initialSessionState = InitialSessionState.CreateDefault();
Start(scriptBlock, new Hashtable());
}
/// <summary> /// Sets a line breakpoint in the debugger. /// </summary> /// <param name="path">The path to the script file where the breakpoint may be hit. This value is required and may not be null.</param> /// <param name="line">The line in the script file where the breakpoint may be hit. This value is required and must be greater than or equal to 1.</param> /// <param name="column">The column in the script file where the breakpoint may be hit. If 0, the breakpoint will trigger on any statement on the line.</param> /// <param name="action">The action to take when the breakpoint is hit. If null, PowerShell will break into the debugger when the breakpoint is hit.</param> /// <param name="runspaceId">The runspace id of the runspace you want to interact with. Defaults to null (current runspace).</param> /// <returns>The line breakpoint that was set.</returns> public override LineBreakpoint SetLineBreakpoint(string path, int line, int column = 0, ScriptBlock action = null, int?runspaceId = null) => _wrappedDebugger.SetLineBreakpoint(path, line, column, action, runspaceId);
public WPFJob(string name, string command, ScriptBlock scriptBlock, InitialSessionState initalSessionState, Hashtable parameters) : base(command, name)
{
this.initialSessionState = initalSessionState;
Start(scriptBlock, parameters);
}
public ScriptTransformationAttribute(ScriptBlock script)
{
_script = script;
}
public ScriptBlock AnotherInvalidParamsBlockTest(ScriptBlock s, int a)
{
return null;
}
/// <summary>
/// Creates an instance of the FilterInfo class with the specified name and ScriptBlock
/// </summary>
///
/// <param name="name">
/// The name of the filter.
/// </param>
///
/// <param name="filter">
/// The ScriptBlock for the filter
/// </param>
///
/// <param name="context">
/// The ExecutionContext for the filter.
/// </param>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="filter"/> is null.
/// </exception>
///
internal FilterInfo(string name, ScriptBlock filter, ExecutionContext context) : this(name, filter, context, null)
{
} // FilterInfo ctor
public ScriptBlock ScriptBlockTest(ScriptBlock block)
{
return block.AppendScript(new InlineScriptSource(ScriptBlockTestScriptName, ScriptBlockTestScript));
}
/// <summary>
/// Creates an instance of the ConfigurationInfo class with the specified name and ScriptBlock
/// </summary>
///
/// <param name="name">
/// The name of the configuration.
/// </param>
///
/// <param name="configuration">
/// The ScriptBlock for the configuration
/// </param>
///
/// <param name="context">
/// The ExecutionContext for the configuration.
/// </param>
///
/// <param name="helpFile">
/// The help file for the configuration.
/// </param>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="configuration"/> is null.
/// </exception>
///
internal ConfigurationInfo(string name, ScriptBlock configuration, ExecutionContext context, string helpFile)
: base(name, configuration, context, helpFile)
{
SetCommandType(CommandTypes.Configuration);
}
public int InvalidReturnBlockTest(ScriptBlock s)
{
return 0;
}
private Collection <PSObject> InvokeScript(
ScriptBlock sb,
bool useNewScope,
PipelineResultTypes writeToPipeline,
IList input,
params object[] args)
{
if (_cmdlet != null)
{
_cmdlet.ThrowIfStopping();
}
Cmdlet cmdletToUse = null;
ScriptBlock.ErrorHandlingBehavior errorHandlingBehavior = ScriptBlock.ErrorHandlingBehavior.WriteToExternalErrorPipe;
// Check if they want output
if ((writeToPipeline & PipelineResultTypes.Output) == PipelineResultTypes.Output)
{
cmdletToUse = _cmdlet;
writeToPipeline &= (~PipelineResultTypes.Output);
}
// Check if they want error
if ((writeToPipeline & PipelineResultTypes.Error) == PipelineResultTypes.Error)
{
errorHandlingBehavior = ScriptBlock.ErrorHandlingBehavior.WriteToCurrentErrorPipe;
writeToPipeline &= (~PipelineResultTypes.Error);
}
if (writeToPipeline != PipelineResultTypes.None)
{
// The only output types are Output and Error.
throw PSTraceSource.NewNotImplementedException();
}
// If the cmdletToUse is not null, then the result of the evaluation will be
// streamed out the output pipe of the cmdlet.
object rawResult;
if (cmdletToUse != null)
{
sb.InvokeUsingCmdlet(
contextCmdlet: cmdletToUse,
useLocalScope: useNewScope,
errorHandlingBehavior: errorHandlingBehavior,
dollarUnder: AutomationNull.Value,
input: input,
scriptThis: AutomationNull.Value,
args: args);
rawResult = AutomationNull.Value;
}
else
{
rawResult = sb.DoInvokeReturnAsIs(
useLocalScope: useNewScope,
errorHandlingBehavior: errorHandlingBehavior,
dollarUnder: AutomationNull.Value,
input: input,
scriptThis: AutomationNull.Value,
args: args);
}
if (rawResult == AutomationNull.Value)
{
return(new Collection <PSObject>());
}
// If the result is already a collection of PSObjects, just return it...
Collection <PSObject> result = rawResult as Collection <PSObject>;
if (result != null)
{
return(result);
}
result = new Collection <PSObject>();
IEnumerator list = null;
list = LanguagePrimitives.GetEnumerator(rawResult);
if (list != null)
{
while (list.MoveNext())
{
object val = list.Current;
result.Add(LanguagePrimitives.AsPSObjectOrNull(val));
}
}
else
{
result.Add(LanguagePrimitives.AsPSObjectOrNull(rawResult));
}
return(result);
}
} // FilterInfo ctor
/// <summary>
/// Creates an instance of the FilterInfo class with the specified name and ScriptBlock
/// </summary>
///
/// <param name="name">
/// The name of the filter.
/// </param>
///
/// <param name="filter">
/// The ScriptBlock for the filter
/// </param>
///
/// <param name="context">
/// The ExecutionContext for the filter.
/// </param>
///
/// <param name="helpFile">
/// The help file for the filter.
/// </param>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="filter"/> is null.
/// </exception>
///
internal FilterInfo(string name, ScriptBlock filter, ExecutionContext context, string helpFile)
: base(name, filter, context, helpFile)
{
SetCommandType(CommandTypes.Filter);
} // FilterInfo ctor
public ScriptState(ScriptState copy)
{
Ref = copy.Ref;
Width = copy.Width;
Height = copy.Height;
Textures = new Dictionary<string, FileInfo>(copy.Textures);
OnLoad = copy.OnLoad.Copy();
OnDeath = copy.OnDeath.Copy();
OnCollision = copy.OnCollision.Copy();
OnKeyPressed = copy.OnKeyPressed.Copy();
OnUpdate = copy.OnUpdate.Copy();
}
public void ScriptBlockSavesSuppliedScripts(InlineScriptSource[] inlineScriptSources)
{
var sut = new ScriptBlock(inlineScriptSources);
Assert.Equal(inlineScriptSources, sut.Scripts);
}
public ScriptState(string reference, int width, int height)
{
Ref = reference;
Width = width;
Height = height;
Textures = new Dictionary<string, FileInfo>();
OnLoad = new ScriptBlock();
OnDeath = new ScriptBlock();
OnCollision = new ScriptBlock();
OnKeyPressed = new ScriptBlock();
OnUpdate = new ScriptBlock();
}
private void SetKeyHandlerInternal(string[] keys, Action <ConsoleKeyInfo?, object> handler, string briefDescription, string longDescription, ScriptBlock scriptBlock)
{
foreach (var key in keys)
{
var chord = ConsoleKeyChordConverter.Convert(key);
var firstKey = PSKeyInfo.FromConsoleKeyInfo(chord[0]);
if (chord.Length == 1)
{
_dispatchTable[firstKey] = MakeKeyHandler(handler, briefDescription, longDescription, scriptBlock);
}
else
{
_dispatchTable[firstKey] = MakeKeyHandler(Chord, "ChordFirstKey");
if (!_chordDispatchTable.TryGetValue(firstKey, out var secondDispatchTable))
{
secondDispatchTable = new Dictionary <PSKeyInfo, KeyHandler>();
_chordDispatchTable[firstKey] = secondDispatchTable;
}
secondDispatchTable[PSKeyInfo.FromConsoleKeyInfo(chord[1])] = MakeKeyHandler(handler, briefDescription, longDescription, scriptBlock);
}
}
}
CreateCommandProcessor
(
ExecutionContext executionContext,
CommandFactory commandFactory,
bool addToHistory,
CommandOrigin origin
)
{
Dbg.Assert(executionContext != null, "Caller should verify the parameters");
Dbg.Assert(commandFactory != null, "Caller should verify the parameters");
CommandProcessorBase commandProcessorBase;
if (IsScript)
{
if ((executionContext.LanguageMode == PSLanguageMode.NoLanguage) &&
(origin == Automation.CommandOrigin.Runspace))
{
throw InterpreterError.NewInterpreterException(CommandText, typeof(ParseException),
null, "ScriptsNotAllowed", ParserStrings.ScriptsNotAllowed);
}
ScriptBlock scriptBlock = executionContext.Engine.ParseScriptBlock(CommandText, addToHistory);
if (origin == Automation.CommandOrigin.Internal)
{
scriptBlock.LanguageMode = PSLanguageMode.FullLanguage;
}
// If running in restricted language mode, verify that the parse tree represents on legitimate
// constructions...
switch (scriptBlock.LanguageMode)
{
case PSLanguageMode.RestrictedLanguage:
scriptBlock.CheckRestrictedLanguage(null, null, false);
break;
case PSLanguageMode.FullLanguage:
// Interactive script commands are permitted in this mode.
break;
case PSLanguageMode.ConstrainedLanguage:
// Constrained Language is checked at runtime.
break;
default:
// This should never happen...
Diagnostics.Assert(false, "Invalid langage mode was set when building a ScriptCommandProcessor");
throw new InvalidOperationException("Invalid langage mode was set when building a ScriptCommandProcessor");
}
if (scriptBlock.UsesCmdletBinding)
{
FunctionInfo functionInfo = new FunctionInfo("", scriptBlock, executionContext);
commandProcessorBase = new CommandProcessor(functionInfo, executionContext,
_useLocalScope ?? false, fromScriptFile: false, sessionState: executionContext.EngineSessionState);
}
else
{
commandProcessorBase = new DlrScriptCommandProcessor(scriptBlock,
executionContext, _useLocalScope ?? false,
origin,
executionContext.EngineSessionState);
}
}
else
{
// RestrictedLanguage / NoLanguage do not support dot-sourcing when CommandOrigin is Runspace
if ((_useLocalScope.HasValue) && (!_useLocalScope.Value))
{
switch (executionContext.LanguageMode)
{
case PSLanguageMode.RestrictedLanguage:
case PSLanguageMode.NoLanguage:
string message = StringUtil.Format(RunspaceStrings.UseLocalScopeNotAllowed,
"UseLocalScope",
PSLanguageMode.RestrictedLanguage.ToString(),
PSLanguageMode.NoLanguage.ToString());
throw new RuntimeException(message);
case PSLanguageMode.FullLanguage:
// Interactive script commands are permitted in this mode...
break;
}
}
commandProcessorBase =
commandFactory.CreateCommand(CommandText, origin, _useLocalScope);
}
CommandParameterCollection parameters = Parameters;
if (parameters != null)
{
bool isNativeCommand = commandProcessorBase is NativeCommandProcessor;
foreach (CommandParameter publicParameter in parameters)
{
CommandParameterInternal internalParameter = CommandParameter.ToCommandParameterInternal(publicParameter, isNativeCommand);
commandProcessorBase.AddParameter(internalParameter);
}
}
string helpTarget;
HelpCategory helpCategory;
if (commandProcessorBase.IsHelpRequested(out helpTarget, out helpCategory))
{
commandProcessorBase = CommandProcessorBase.CreateGetHelpCommandProcessor(
executionContext,
helpTarget,
helpCategory);
}
//Set the merge settings
SetMergeSettingsOnCommandProcessor(commandProcessorBase);
return(commandProcessorBase);
}
/// <summary>
///
/// </summary>
/// <param name="powerShellVersion"></param>
/// <param name="credential"></param>
/// <param name="initializationScript"></param>
/// <param name="useWow64"></param>
public PowerShellProcessInstance(Version powerShellVersion, PSCredential credential, ScriptBlock initializationScript, bool useWow64)
{
string psWow64Path = s_PSExePath;
if (useWow64)
{
string procArch = Environment.GetEnvironmentVariable("PROCESSOR_ARCHITECTURE");
if ((!string.IsNullOrEmpty(procArch)) && (procArch.Equals("amd64", StringComparison.OrdinalIgnoreCase) ||
procArch.Equals("ia64", StringComparison.OrdinalIgnoreCase)))
{
psWow64Path = s_PSExePath.ToLowerInvariant().Replace("\\system32\\", "\\syswow64\\");
if (!File.Exists(psWow64Path))
{
string message =
PSRemotingErrorInvariants.FormatResourceString(
RemotingErrorIdStrings.IPCWowComponentNotPresent,
psWow64Path);
throw new PSInvalidOperationException(message);
}
}
}
string processArguments = string.Empty;
// Adding Version parameter to powershell.exe
// Version parameter needs to go before all other parameters because the native layer looks for Version or
// PSConsoleFile parameters before parsing other parameters.
// The other parameters get parsed in the managed layer.
Version tempVersion = powerShellVersion ?? PSVersionInfo.PSVersion;
processArguments = string.Format(CultureInfo.InvariantCulture,
"-Version {0}", new Version(tempVersion.Major, tempVersion.Minor));
processArguments = string.Format(CultureInfo.InvariantCulture,
"{0} -s -NoLogo -NoProfile", processArguments);
if (initializationScript != null)
{
string scripBlockAsString = initializationScript.ToString();
if (!string.IsNullOrEmpty(scripBlockAsString))
{
string encodedCommand =
Convert.ToBase64String(Encoding.Unicode.GetBytes(scripBlockAsString));
processArguments = string.Format(CultureInfo.InvariantCulture,
"{0} -EncodedCommand {1}", processArguments, encodedCommand);
}
}
// 'WindowStyle' is used only if 'UseShellExecute' is 'true'. Since 'UseShellExecute' is set
// to 'false' in our use, we can ignore the 'WindowStyle' setting in the initialization below.
_startInfo = new ProcessStartInfo
{
FileName = useWow64 ? psWow64Path : s_PSExePath,
Arguments = processArguments,
UseShellExecute = false,
RedirectStandardInput = true,
RedirectStandardOutput = true,
RedirectStandardError = true,
CreateNoWindow = true,
LoadUserProfile = true,
};
if (credential != null)
{
Net.NetworkCredential netCredential = credential.GetNetworkCredential();
_startInfo.UserName = netCredential.UserName;
_startInfo.Domain = string.IsNullOrEmpty(netCredential.Domain) ? "." : netCredential.Domain;
#if CORECLR
_startInfo.PasswordInClearText = ClrFacade.ConvertSecureStringToString(credential.Password);
#else
_startInfo.Password = credential.Password;
#endif
}
Process = new Process { StartInfo = _startInfo, EnableRaisingEvents = true };
}
/// <summary>
/// Creates an instance of the ConfigurationInfo class with the specified name and ScriptBlock
/// </summary>
///
/// <param name="name">
/// The name of the configuration.
/// </param>
///
/// <param name="configuration">
/// The ScriptBlock for the configuration
/// </param>
///
/// <param name="options">
/// The options to set on the function. Note, Constant can only be set at creation time.
/// </param>
///
/// <param name="context">
/// The execution context for the configuration.
/// </param>
///
/// <param name="helpFile">
/// The help file for the configuration.
/// </param>
///
/// <param name="isMetaConfig">The configuration is a meta configuration</param>
///
/// <exception cref="ArgumentNullException">
/// If <paramref name="configuration"/> is null.
/// </exception>
///
internal ConfigurationInfo(string name, ScriptBlock configuration, ScopedItemOptions options, ExecutionContext context, string helpFile, bool isMetaConfig)
: base(name, configuration, options, context, helpFile)
{
SetCommandType(CommandTypes.Configuration);
IsMetaConfiguration = isMetaConfig;
}
