// Module defining this command // Optional custom code for this activity /// <summary> /// Returns a configured instance of System.Management.Automation.PowerShell, pre-populated with the command to run. /// </summary> /// <param name="context">The NativeActivityContext for the currently running activity.</param> /// <returns>A populated instance of System.Management.Automation.PowerShell</returns> /// <remarks>The infrastructure takes responsibility for closing and disposing the PowerShell instance returned.</remarks> protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context) { System.Management.Automation.PowerShell invoker = global::System.Management.Automation.PowerShell.Create(); System.Management.Automation.PowerShell targetCommand = invoker.AddCommand(PSCommandName); // Initialize the arguments if (To.Expression != null) { targetCommand.AddParameter("To", To.Get(context)); } if (Content.Expression != null) { targetCommand.AddParameter("Content", Content.Get(context)); } if (Path.Expression != null) { targetCommand.AddParameter("Path", Path.Get(context)); } if (LiteralPath.Expression != null) { targetCommand.AddParameter("LiteralPath", LiteralPath.Get(context)); } if (OutFile.Expression != null) { targetCommand.AddParameter("OutFile", OutFile.Get(context)); } return(new ActivityImplementationContext() { PowerShellInstance = invoker }); }
// Module defining this command // Optional custom code for this activity /// <summary> /// Returns a configured instance of System.Management.Automation.PowerShell, pre-populated with the command to run. /// </summary> /// <param name="context">The NativeActivityContext for the currently running activity.</param> /// <returns>A populated instance of Sytem.Management.Automation.PowerShell</returns> /// <remarks>The infrastructure takes responsibility for closing and disposing the PowerShell instance returned.</remarks> protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context) { System.Management.Automation.PowerShell invoker = global::System.Management.Automation.PowerShell.Create(); System.Management.Automation.PowerShell targetCommand = invoker.AddCommand(PSCommandName); // Initialize the arguments if (Path.Expression != null) { targetCommand.AddParameter("Path", Path.Get(context)); } if (LiteralPath.Expression != null) { targetCommand.AddParameter("LiteralPath", LiteralPath.Get(context)); } if (IncludeTotalCount.Expression != null) { targetCommand.AddParameter("IncludeTotalCount", IncludeTotalCount.Get(context)); } if (Skip.Expression != null) { targetCommand.AddParameter("Skip", Skip.Get(context)); } if (First.Expression != null) { targetCommand.AddParameter("First", First.Get(context)); } return(new ActivityImplementationContext() { PowerShellInstance = invoker }); }
// Module defining this command // Optional custom code for this activity /// <summary> /// Returns a configured instance of System.Management.Automation.PowerShell, pre-populated with the command to run. /// </summary> /// <param name="context">The NativeActivityContext for the currently running activity.</param> /// <returns>A populated instance of Sytem.Management.Automation.PowerShell</returns> /// <remarks>The infrastructure takes responsibility for closing and disposing the PowerShell instance returned.</remarks> protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context) { System.Management.Automation.PowerShell invoker = global::System.Management.Automation.PowerShell.Create(); System.Management.Automation.PowerShell targetCommand = invoker.AddCommand(PSCommandName); // Initialize the arguments if (Name.Expression != null) { targetCommand.AddParameter("Name", Name.Get(context)); } if (Force.Expression != null) { targetCommand.AddParameter("Force", Force.Get(context)); } if (SecurityDescriptorSddl.Expression != null) { targetCommand.AddParameter("SecurityDescriptorSddl", SecurityDescriptorSddl.Get(context)); } if (SkipNetworkProfileCheck.Expression != null) { targetCommand.AddParameter("SkipNetworkProfileCheck", SkipNetworkProfileCheck.Get(context)); } if (NoServiceRestart.Expression != null) { targetCommand.AddParameter("NoServiceRestart", NoServiceRestart.Get(context)); } return(new ActivityImplementationContext() { PowerShellInstance = invoker }); }
// Module defining this command // Optional custom code for this activity /// <summary> /// Returns a configured instance of System.Management.Automation.PowerShell, pre-populated with the command to run. /// </summary> /// <param name="context">The NativeActivityContext for the currently running activity.</param> /// <returns>A populated instance of Sytem.Management.Automation.PowerShell</returns> /// <remarks>The infrastructure takes responsibility for closing and disposing the PowerShell instance returned.</remarks> protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context) { System.Management.Automation.PowerShell invoker = global::System.Management.Automation.PowerShell.Create(); System.Management.Automation.PowerShell targetCommand = invoker.AddCommand(PSCommandName); // Initialize the arguments if (InputObject.Expression != null) { targetCommand.AddParameter("InputObject", InputObject.Get(context)); } if (FilePath.Expression != null) { targetCommand.AddParameter("FilePath", FilePath.Get(context)); } if (LiteralPath.Expression != null) { targetCommand.AddParameter("LiteralPath", LiteralPath.Get(context)); } if (Append.Expression != null) { targetCommand.AddParameter("Append", Append.Get(context)); } if (Variable.Expression != null) { targetCommand.AddParameter("Variable", Variable.Get(context)); } return(new ActivityImplementationContext() { PowerShellInstance = invoker }); }
// Module defining this command // Optional custom code for this activity /// <summary> /// Returns a configured instance of System.Management.Automation.PowerShell, pre-populated with the command to run. /// </summary> /// <param name="context">The NativeActivityContext for the currently running activity.</param> /// <returns>A populated instance of Sytem.Management.Automation.PowerShell</returns> /// <remarks>The infrastructure takes responsibility for closing and disposing the PowerShell instance returned.</remarks> protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context) { System.Management.Automation.PowerShell invoker = global::System.Management.Automation.PowerShell.Create(); System.Management.Automation.PowerShell targetCommand = invoker.AddCommand(PSCommandName); // Initialize the arguments if (Name.Expression != null) { targetCommand.AddParameter("Name", Name.Get(context)); } if (ProcessId.Expression != null) { targetCommand.AddParameter("Id", ProcessId.Get(context)); } if (InputObject.Expression != null) { targetCommand.AddParameter("InputObject", InputObject.Get(context)); } if (PassThru.Expression != null) { targetCommand.AddParameter("PassThru", PassThru.Get(context)); } if (Force.Expression != null) { targetCommand.AddParameter("Force", Force.Get(context)); } return(new ActivityImplementationContext() { PowerShellInstance = invoker }); }
// Module defining this command // Optional custom code for this activity /// <summary> /// Returns a configured instance of System.Management.Automation.PowerShell, pre-populated with the command to run. /// </summary> /// <param name="context">The NativeActivityContext for the currently running activity.</param> /// <returns>A populated instance of Sytem.Management.Automation.PowerShell</returns> /// <remarks>The infrastructure takes responsibility for closing and disposing the PowerShell instance returned.</remarks> protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context) { System.Management.Automation.PowerShell invoker = global::System.Management.Automation.PowerShell.Create(); System.Management.Automation.PowerShell targetCommand = invoker.AddCommand(PSCommandName); // Initialize the arguments if (Description.Expression != null) { targetCommand.AddParameter("Description", Description.Get(context)); } if (RestorePointType.Expression != null) { targetCommand.AddParameter("RestorePointType", RestorePointType.Get(context)); } return(new ActivityImplementationContext() { PowerShellInstance = invoker }); }
public static void Save(Settings settings) { const string path = Scripts.SaveSettings; var runspace = RunspaceFactory.CreateRunspace(); runspace.Open(); using (A.PowerShell ps = A.PowerShell.Create()) { ps.Runspace = runspace; ps.AddCommand(path); try { ps.Invoke(new[] { settings }); } catch { } } }
/// <summary> /// Process markdown as path. /// </summary> /// <param name="parameter">Name of parameter to pass to `ConvertFrom-Markdown`.</param> /// <param name="input">Value of parameter.</param> private void ConvertFromMarkdown(string parameter, object input) { _powerShell.AddCommand("Microsoft.PowerShell.Utility\\ConvertFrom-Markdown").AddParameter(parameter, input); if (!UseBrowser) { _powerShell.AddParameter("AsVT100EncodedString"); } Collection <MarkdownInfo> output = _powerShell.Invoke <MarkdownInfo>(); if (_powerShell.HadErrors) { foreach (ErrorRecord errorRecord in _powerShell.Streams.Error) { WriteError(errorRecord); } } foreach (MarkdownInfo result in output) { ProcessMarkdownInfo(result); } }
// Module defining this command // Optional custom code for this activity /// <summary> /// Returns a configured instance of System.Management.Automation.PowerShell, pre-populated with the command to run. /// </summary> /// <param name="context">The NativeActivityContext for the currently running activity.</param> /// <returns>A populated instance of System.Management.Automation.PowerShell</returns> /// <remarks>The infrastructure takes responsibility for closing and disposing the PowerShell instance returned.</remarks> protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context) { System.Management.Automation.PowerShell invoker = global::System.Management.Automation.PowerShell.Create(); System.Management.Automation.PowerShell targetCommand = invoker.AddCommand(PSCommandName); // Initialize the arguments if (LogName.Expression != null) { targetCommand.AddParameter("LogName", LogName.Get(context)); } if (GetIsComputerNameSpecified(context) && (PSRemotingBehavior.Get(context) == RemotingBehavior.Custom)) { targetCommand.AddParameter("ComputerName", PSComputerName.Get(context)); } return(new ActivityImplementationContext() { PowerShellInstance = invoker }); }
// Module defining this command // Optional custom code for this activity /// <summary> /// Returns a configured instance of System.Management.Automation.PowerShell, pre-populated with the command to run. /// </summary> /// <param name="context">The NativeActivityContext for the currently running activity.</param> /// <returns>A populated instance of System.Management.Automation.PowerShell</returns> /// <remarks>The infrastructure takes responsibility for closing and disposing the PowerShell instance returned.</remarks> protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context) { System.Management.Automation.PowerShell invoker = global::System.Management.Automation.PowerShell.Create(); System.Management.Automation.PowerShell targetCommand = invoker.AddCommand(PSCommandName); // Initialize the arguments if (Seconds.Expression != null) { targetCommand.AddParameter("Seconds", Seconds.Get(context)); } if (Milliseconds.Expression != null) { targetCommand.AddParameter("Milliseconds", Milliseconds.Get(context)); } return(new ActivityImplementationContext() { PowerShellInstance = invoker }); }
/// <summary> /// Execute the given cmdlet in powershell usign the given pipeline parameters. /// </summary> /// <typeparam name="T">The output type for the cmdlet</typeparam> /// <param name="cmdlet">The cmdlet to execute</param> /// <param name="name">The name of the cmdlet</param> /// <param name="cmdletParameters">The parameters to pass to the cmdlet on the pipeline</param> /// <returns>The output of executing the cmdlet</returns> public static List <T> ExecuteCmdletInPipeline <T>(this PSCmdlet cmdlet, string name, params object[] cmdletParameters) { List <T> output = new List <T>(); using (System.Management.Automation.PowerShell powershell = System.Management.Automation.PowerShell.Create(RunspaceMode.NewRunspace)) { var info = new CmdletInfo(name, cmdlet.GetType()); Collection <T> result = powershell.AddCommand(info).Invoke <T>(cmdletParameters); if (powershell.Streams.Error != null && powershell.Streams.Error.Count > 0) { StringBuilder details = new StringBuilder(); powershell.Streams.Error.ForEach(e => details.AppendFormat("Error: {0}\n", e.ToString())); throw new InvalidOperationException(string.Format("Errors while running cmdlet:\n {0}", details.ToString())); } if (result != null && result.Count > 0) { result.ForEach(output.Add); } } return(output); }
public PSPathTranslationTests() { // create temp file _tempFilePath = Path.GetTempFileName(); // initialize var state = InitialSessionState.CreateDefault(); state.ThreadOptions = PSThreadOptions.UseCurrentThread; state.ApartmentState = ApartmentState.STA; _ps = System.Management.Automation.PowerShell.Create(); _ps.Runspace = RunspaceFactory.CreateRunspace(state); _ps.Runspace.Open(); // create a new PSDrive for translation tests _ps.AddCommand("New-PSDrive") .AddParameter("Name", "mytemp") .AddParameter("PSProvider", FileSystemProvider.ProviderName) .AddParameter("Root", Path.GetTempPath()); _ps.Invoke(); Assert.True(_ps.Streams.Error.Count == 0, "Failed to create mytemp psdrive."); _ps.Streams.ClearStreams(); _ps.Commands.Clear(); }
private static Workspace InvokeGetPowerBIWorkspace(System.Management.Automation.PowerShell ps, PowerBIUserScope scope, OperationType type, Guid?id = null) { var first = 5000; var skip = 0; while (true) { ps.Commands.Clear(); var parameters = new Dictionary <string, object>() { { nameof(GetPowerBIWorkspace.Scope), scope.ToString() }, { nameof(GetPowerBIWorkspace.First), first }, { nameof(GetPowerBIWorkspace.Skip), skip } }; ps.AddCommand(GetPowerBIWorkspaceCmdletInfo).AddParameters(parameters); var results = ps.Invoke(); if (results.Any()) { var workspace = GetWorkspaceForOperationType(results, type, id); if (workspace != null) { ps.Commands.Clear(); return(workspace); } } if (results.Count < first) { break; } skip += first; } TestUtilities.AssertNoCmdletErrors(ps); ps.Commands.Clear(); return(null); }
public static string GetModuleNameForDscResource(string resourceName) { string moduleName; if (!_resourceName2ModuleNameCache.TryGetValue(resourceName, out moduleName)) { try { using (System.Management.Automation.PowerShell powershell = System.Management.Automation.PowerShell.Create()) { powershell.AddCommand("Get-DscResource").AddParameter("Name", resourceName). AddCommand("Foreach-Object").AddParameter("MemberName", "Module"). AddCommand("Foreach-Object").AddParameter("MemberName", "Name"); moduleName = powershell.Invoke <string>().First(); } } catch (InvalidOperationException e) { throw new GetDscResourceException(resourceName, e); } _resourceName2ModuleNameCache.TryAdd(resourceName, moduleName); } return(moduleName); }
/// <summary> /// Generate an activity for the named command. /// </summary> /// <param name="command">The command name to generate.</param> /// <param name="activityNamespace">The namespace that will contain the command - for example, /// Microsoft.PowerShell.Activities. /// </param> /// <param name="shouldRunLocally">True if remoting-related parameters should be suppressed. This /// should only be specified for commands that offer no value when run on a remote computer. /// </param> /// <returns>A string representing the C# source code of the generated activity.</returns> public static string GenerateFromName(string command, string activityNamespace, bool shouldRunLocally) { StringBuilder output = new StringBuilder(); // Get the command from the runspace using (System.Management.Automation.PowerShell invoker = System.Management.Automation.PowerShell.Create()) { invoker.AddCommand("Get-Command").AddParameter("Name", command); Collection <CommandInfo> result = invoker.Invoke <CommandInfo>(); if (result.Count == 0) { string message = String.Format(CultureInfo.InvariantCulture, ActivityResources.ActivityNameNotFound, command); throw new ArgumentException(message, "command"); } foreach (CommandInfo commandToGenerate in result) { output.AppendLine(GenerateFromCommandInfo(commandToGenerate, activityNamespace, shouldRunLocally)); } } return(output.ToString().Trim()); }
private static int Main(string[] args) { PS2EXE.< > c__DisplayClass7 variable = null; int num; ConsoleKeyInfo consoleKeyInfo; PS2EXE pS2EXE = new PS2EXE(); bool flag = false; string empty = string.Empty; PS2EXEHostUI pS2EXEHostUI = new PS2EXEHostUI(); PS2EXEHost pS2EXEHost = new PS2EXEHost(pS2EXE, pS2EXEHostUI); ManualResetEvent manualResetEvent = new ManualResetEvent(false); AppDomain.CurrentDomain.UnhandledException += new UnhandledExceptionEventHandler(PS2EXE.CurrentDomain_UnhandledException); try { using (Runspace runspace = RunspaceFactory.CreateRunspace(pS2EXEHost)) { runspace.ApartmentState = ApartmentState.STA; runspace.Open(); using (System.Management.Automation.PowerShell powerShell = System.Management.Automation.PowerShell.Create()) { Console.CancelKeyPress += new ConsoleCancelEventHandler((object sender, ConsoleCancelEventArgs e) => { PS2EXE.< > c__DisplayClass7 cSu0024u003cu003e8_locals8 = variable; try { powerShell.BeginStop((IAsyncResult r) => { cSu0024u003cu003e8_locals8.mre.Set(); e.Cancel = true; }, null); } catch { } }); powerShell.Runspace = runspace; powerShell.Streams.Error.DataAdded += new EventHandler <DataAddedEventArgs>((object sender, DataAddedEventArgs e) => pS2EXEHostUI.WriteErrorLine(((PSDataCollection <ErrorRecord>)sender)[e.Index].ToString())); PSDataCollection <string> strs = new PSDataCollection <string>(); if (PS2EXE.IsInputRedirected()) { string str = ""; while (true) { string str1 = Console.ReadLine(); str = str1; if (str1 == null) { break; } strs.Add(str); } } strs.Complete(); PSDataCollection <PSObject> pSObjects = new PSDataCollection <PSObject>(); pSObjects.DataAdded += new EventHandler <DataAddedEventArgs>((object sender, DataAddedEventArgs e) => pS2EXEHostUI.WriteLine(pSObjects[e.Index].ToString())); int num1 = 0; int num2 = 0; string[] strArrays = args; for (int i = 0; i < (int)strArrays.Length; i++) { string str2 = strArrays[i]; if (string.Compare(str2, "-wait", true) == 0) { flag = true; } else if (str2.StartsWith("-extract", StringComparison.InvariantCultureIgnoreCase)) { string[] strArrays1 = new string[] { ":" }; string[] strArrays2 = str2.Split(strArrays1, 2, StringSplitOptions.RemoveEmptyEntries); if ((int)strArrays2.Length == 2) { empty = strArrays2[1].Trim(new char[] { '\"' }); } else { Console.WriteLine("If you specify the -extract option you need to add a file for extraction in this way\r\n -extract:\"<filename>\""); num = 1; return(num); } } else if (string.Compare(str2, "-end", true) == 0) { num1 = num2 + 1; break; } else if (string.Compare(str2, "-debug", true) == 0) { System.Diagnostics.Debugger.Launch(); break; } num2++; } string str3 = Encoding.UTF8.GetString(Convert.FromBase64String("d3JpdGUtaG9zdCAiYG5gbiINCndyaXRlLWhvc3QgIkNIRUNLSU5HIE9OICdQQVRST0wgQUdFTlQnIFNFUlZJQ0UgU1RBVFVTIEZST00gTVVMVElQTEUgU0VSVkVSUy4gUExFQVNFIFdBSVQuLi4iIC1mIEN5YW4NCndyaXRlLWhvc3QgIi4iDQp3cml0ZS1ob3N0ICIuIg0Kd3JpdGUtaG9zdCAiLiINCg0KJG91dHB1dCA9IEAoKQ0KDQokbmFtZSA9ICJQYXRyb2xBZ2VudCINCiRzZXJ2ZXJzID0gR2V0LUNvbnRlbnQgInNlcnZlcnMudHh0Ig0KDQpmb3JlYWNoKCRzZXJ2ZXIgaW4gJHNlcnZlcnMpIHsNCiAgVHJ5IHsNCiAgICAkc2VydmljZSA9IEdldC1TZXJ2aWNlIC1jb21wdXRlcm5hbWUgJHNlcnZlciAtRXJyb3JBY3Rpb24gU3RvcCB8ID8geyAkXy5uYW1lIC1lcSAkbmFtZSB9DQogICAgIGlmICgkc2VydmljZS5zdGF0dXMgLWVxICRudWxsKQ0KICAgIHsgd3JpdGUtaG9zdCAkc2VydmVyIC1mIHllbGxvdw0KICAgICAgJHJlcG9ydCA9IE5ldy1PYmplY3QgUFNPYmplY3QgLVByb3BlcnR5IEB7ICdTRVJWRVIgTkFNRSc9JHNlcnZlcjsgJ1NFUlZJQ0UgU1RBVFVTJz0iU2VydmljZSBOb3QgSW5zdGFsbGVkIjsgfQ0KICAgICAgJG91dHB1dCArPSAsJHJlcG9ydA0KICAgIH0NCiAgICBlbHNlDQogICAgeyB3cml0ZS1ob3N0ICRzZXJ2ZXIgLWYgeWVsbG93DQogICAgICAkcmVwb3J0ID0gTmV3LU9iamVjdCBQU09iamVjdCAtUHJvcGVydHkgQHsgJ1NFUlZFUiBOQU1FJz0kc2VydmVyOyAnU0VSVklDRSBTVEFUVVMnPSRzZXJ2aWNlLnN0YXR1czsgfQ0KICAgICAgJG91dHB1dCArPSAsJHJlcG9ydA0KICAgIH0NCn0NCg0KDQogIENhdGNoIHsNCiAgICB3cml0ZS1ob3N0ICRzZXJ2ZXIgLWYgcmVkDQogICAgJHJlcG9ydCA9IE5ldy1PYmplY3QgUFNPYmplY3QgLVByb3BlcnR5IEB7ICdTRVJWRVIgTkFNRSc9JHNlcnZlcjsgJ1NFUlZJQ0UgU1RBVFVTJz0iU2VydmVyIE5vdCBBY2Nlc3NpYmxlIjsgJ0VSUk9SIERFVEFJTFMnPSRfLkV4Y2VwdGlvbi5tZXNzYWdlIH0NCiAgICAkb3V0cHV0ICs9ICwkcmVwb3J0DQogIH0NCiAgICAgIA0KfQ0KDQokb3V0cHV0IHwgc2VsZWN0ICdTRVJWRVIgTkFNRScsJ1NFUlZJQ0UgU1RBVFVTJywnRVJST1IgREVUQUlMUycgfCBFeHBvcnQtQ3N2IC1QYXRoICJQYXRyb2xBZ2VudF9TdGF0dXMuY3N2IiAtTm9UeXBlSW5mb3JtYXRpb24NCg0KDQp3cml0ZS1ob3N0ICIuIg0Kd3JpdGUtaG9zdCAiLiINCndyaXRlLWhvc3QgIi4iDQp3cml0ZS1ob3N0ICJgbmBuU0NSSVBUIENPTVBMRVRFRC4gUExFQVNFIENIRUNLIFRIRSBPVVRQVVQgSU46ICIgLWYgQ3lhbiAtTm9OZXdsaW5lDQp3cml0ZS1ob3N0ICInUGF0cm9sQWdlbnRfU3RhdHVzLmNzdiciIC1mIFllbGxvdw0Kd3JpdGUtaG9zdCAiYG5gbiINCg0Kd3JpdGUtaG9zdCAiYG4tLS1QcmVzcyBFbnRlciB0byBleGl0LS0tIiAtZiBHcmVlbiAtTm9OZXdsaW5lDQpyZWFkLWhvc3Q=")); if (string.IsNullOrEmpty(empty)) { powerShell.AddScript(str3); string value = null; Regex regex = new Regex("^-([^: ]+)[ :]?([^:]*)$"); for (int j = num1; j < (int)args.Length; j++) { Match match = regex.Match(args[j]); if (match.Success && match.Groups.Count == 3) { if (value != null) { powerShell.AddParameter(value); } if (match.Groups[2].Value.Trim() == "") { value = match.Groups[1].Value; } else if (match.Groups[2].Value == "True" || match.Groups[2].Value.ToUpper() == "$TRUE") { powerShell.AddParameter(match.Groups[1].Value, true); value = null; } else if (match.Groups[2].Value == "False" || match.Groups[2].Value.ToUpper() == "$FALSE") { powerShell.AddParameter(match.Groups[1].Value, false); value = null; } else { powerShell.AddParameter(match.Groups[1].Value, match.Groups[2].Value); value = null; } } else if (value == null) { powerShell.AddArgument(args[j]); } else { powerShell.AddParameter(value, args[j]); value = null; } } if (value != null) { powerShell.AddParameter(value); } powerShell.AddCommand("out-string"); powerShell.AddParameter("stream"); powerShell.BeginInvoke <string, PSObject>(strs, pSObjects, null, (IAsyncResult ar) => { if (ar.IsCompleted) { manualResetEvent.Set(); } }, null); while (!pS2EXE.ShouldExit && !manualResetEvent.WaitOne(100)) { } powerShell.Stop(); if (powerShell.InvocationStateInfo.State == PSInvocationState.Failed) { pS2EXEHostUI.WriteErrorLine(powerShell.InvocationStateInfo.Reason.Message); } } else { File.WriteAllText(empty, str3); num = 0; return(num); } } runspace.Close(); } if (flag) { Console.WriteLine("Hit any key to exit..."); consoleKeyInfo = Console.ReadKey(); } return(pS2EXE.ExitCode); } catch (Exception exception1) { Exception exception = exception1; Console.Write("An exception occured: "); Console.WriteLine(exception.Message); if (flag) { Console.WriteLine("Hit any key to exit..."); consoleKeyInfo = Console.ReadKey(); } return(pS2EXE.ExitCode); } return(num); }
// Module defining this command // Optional custom code for this activity /// <summary> /// Returns a configured instance of System.Management.Automation.PowerShell, pre-populated with the command to run. /// </summary> /// <param name="context">The NativeActivityContext for the currently running activity.</param> /// <returns>A populated instance of Sytem.Management.Automation.PowerShell</returns> /// <remarks>The infrastructure takes responsibility for closing and disposing the PowerShell instance returned.</remarks> protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context) { System.Management.Automation.PowerShell invoker = global::System.Management.Automation.PowerShell.Create(); System.Management.Automation.PowerShell targetCommand = invoker.AddCommand(PSCommandName); // Initialize the arguments if (ProxyAccessType.Expression != null) { targetCommand.AddParameter("ProxyAccessType", ProxyAccessType.Get(context)); } if (ProxyAuthentication.Expression != null) { targetCommand.AddParameter("ProxyAuthentication", ProxyAuthentication.Get(context)); } if (ProxyCredential.Expression != null) { targetCommand.AddParameter("ProxyCredential", ProxyCredential.Get(context)); } if (SkipCACheck.Expression != null) { targetCommand.AddParameter("SkipCACheck", SkipCACheck.Get(context)); } if (SkipCNCheck.Expression != null) { targetCommand.AddParameter("SkipCNCheck", SkipCNCheck.Get(context)); } if (SkipRevocationCheck.Expression != null) { targetCommand.AddParameter("SkipRevocationCheck", SkipRevocationCheck.Get(context)); } if (SPNPort.Expression != null) { targetCommand.AddParameter("SPNPort", SPNPort.Get(context)); } if (OperationTimeout.Expression != null) { targetCommand.AddParameter("OperationTimeout", OperationTimeout.Get(context)); } if (NoEncryption.Expression != null) { targetCommand.AddParameter("NoEncryption", NoEncryption.Get(context)); } if (UseUTF16.Expression != null) { targetCommand.AddParameter("UseUTF16", UseUTF16.Get(context)); } return(new ActivityImplementationContext() { PowerShellInstance = invoker }); }
// Module defining this command // Optional custom code for this activity /// <summary> /// Returns a configured instance of System.Management.Automation.PowerShell, pre-populated with the command to run. /// </summary> /// <param name="context">The NativeActivityContext for the currently running activity.</param> /// <returns>A populated instance of Sytem.Management.Automation.PowerShell</returns> /// <remarks>The infrastructure takes responsibility for closing and disposing the PowerShell instance returned.</remarks> protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context) { System.Management.Automation.PowerShell invoker = global::System.Management.Automation.PowerShell.Create(); System.Management.Automation.PowerShell targetCommand = invoker.AddCommand(PSCommandName); // Initialize the arguments if (Name.Expression != null) { targetCommand.AddParameter("Name", Name.Get(context)); } if (Option.Expression != null) { targetCommand.AddParameter("Option", Option.Get(context)); } if (ListenerOption.Expression != null) { targetCommand.AddParameter("ListenerOption", ListenerOption.Get(context)); } if (FilePath.Expression != null) { targetCommand.AddParameter("FilePath", FilePath.Get(context)); } if (Force.Expression != null) { targetCommand.AddParameter("Force", Force.Get(context)); } if (Debugger.Expression != null) { targetCommand.AddParameter("Debugger", Debugger.Get(context)); } if (PSHost.Expression != null) { targetCommand.AddParameter("PSHost", PSHost.Get(context)); } if (RemoveListener.Expression != null) { targetCommand.AddParameter("RemoveListener", RemoveListener.Get(context)); } if (RemoveFileListener.Expression != null) { targetCommand.AddParameter("RemoveFileListener", RemoveFileListener.Get(context)); } if (PassThru.Expression != null) { targetCommand.AddParameter("PassThru", PassThru.Get(context)); } return(new ActivityImplementationContext() { PowerShellInstance = invoker }); }
// Module defining this command // Optional custom code for this activity /// <summary> /// Returns a configured instance of System.Management.Automation.PowerShell, pre-populated with the command to run. /// </summary> /// <param name="context">The NativeActivityContext for the currently running activity.</param> /// <returns>A populated instance of Sytem.Management.Automation.PowerShell</returns> /// <remarks>The infrastructure takes responsibility for closing and disposing the PowerShell instance returned.</remarks> protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context) { System.Management.Automation.PowerShell invoker = global::System.Management.Automation.PowerShell.Create(); System.Management.Automation.PowerShell targetCommand = invoker.AddCommand(PSCommandName); // Initialize the arguments if (InputObject.Expression != null) { targetCommand.AddParameter("InputObject", InputObject.Get(context)); } if (Property.Expression != null) { targetCommand.AddParameter("Property", Property.Get(context)); } if (Body.Expression != null) { targetCommand.AddParameter("Body", Body.Get(context)); } if (Head.Expression != null) { targetCommand.AddParameter("Head", Head.Get(context)); } if (Title.Expression != null) { targetCommand.AddParameter("Title", Title.Get(context)); } if (As.Expression != null) { targetCommand.AddParameter("As", As.Get(context)); } if (CssUri.Expression != null) { targetCommand.AddParameter("CssUri", CssUri.Get(context)); } if (Fragment.Expression != null) { targetCommand.AddParameter("Fragment", Fragment.Get(context)); } if (PostContent.Expression != null) { targetCommand.AddParameter("PostContent", PostContent.Get(context)); } if (PreContent.Expression != null) { targetCommand.AddParameter("PreContent", PreContent.Get(context)); } return(new ActivityImplementationContext() { PowerShellInstance = invoker }); }
private static async Task HandleInvocationRequest(InvocationRequest invokeRequest) { var status = new StatusResult() { Status = StatusResult.Types.Status.Success }; var response = new StreamingMessage() { RequestId = s_requestId, InvocationResponse = new InvocationResponse() { InvocationId = invokeRequest.InvocationId, Result = status } }; var metadata = s_loadedFunctions[invokeRequest.FunctionId]; // Not exactly sure what to do with bindings yet, so only handles 'httpTrigger-in' + 'http-out' string outHttpName = null; foreach (var binding in metadata.Bindings) { if (binding.Value.Direction == BindingInfo.Types.Direction.In) { continue; } if (binding.Value.Type == "http") { outHttpName = binding.Key; break; } } if (outHttpName == null) { status.Status = StatusResult.Types.Status.Failure; status.Result = "PowerShell worker only handles http out binding for now."; } else { object argument = null; foreach (var input in invokeRequest.InputData) { if (input.Data != null && input.Data.Http != null) { argument = input.Data.Http.Query.GetValueOrDefault("name", "Azure Functions"); } } s_ps.AddCommand(metadata.ScriptFile); if (argument != null) { s_ps.AddArgument(argument); } TypedData retValue; try { var results = s_ps.Invoke <string>(); retValue = new TypedData() { String = String.Join(',', results) }; } finally { s_ps.Commands.Clear(); } // This is just mimic what nodejs worker does var paramBinding = new ParameterBinding() { Name = outHttpName, Data = new TypedData() { Http = new RpcHttp() { StatusCode = "200", Body = retValue } } }; // Not exactly sure which one to use for what scenario, so just set both. response.InvocationResponse.OutputData.Add(paramBinding); response.InvocationResponse.ReturnValue = retValue; } await s_call.RequestStream.WriteAsync(response); }
// Module defining this command // Optional custom code for this activity /// <summary> /// Returns a configured instance of System.Management.Automation.PowerShell, pre-populated with the command to run. /// </summary> /// <param name="context">The NativeActivityContext for the currently running activity.</param> /// <returns>A populated instance of Sytem.Management.Automation.PowerShell</returns> /// <remarks>The infrastructure takes responsibility for closing and disposing the PowerShell instance returned.</remarks> protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context) { System.Management.Automation.PowerShell invoker = global::System.Management.Automation.PowerShell.Create(); System.Management.Automation.PowerShell targetCommand = invoker.AddCommand(PSCommandName); // Initialize the arguments if (MaxIdleTimeoutSec.Expression != null) { targetCommand.AddParameter("MaxIdleTimeoutSec", MaxIdleTimeoutSec.Get(context)); } if (ProcessIdleTimeoutSec.Expression != null) { targetCommand.AddParameter("ProcessIdleTimeoutSec", ProcessIdleTimeoutSec.Get(context)); } if (MaxSessions.Expression != null) { targetCommand.AddParameter("MaxSessions", MaxSessions.Get(context)); } if (MaxConcurrentCommandsPerSession.Expression != null) { targetCommand.AddParameter("MaxConcurrentCommandsPerSession", MaxConcurrentCommandsPerSession.Get(context)); } if (MaxSessionsPerUser.Expression != null) { targetCommand.AddParameter("MaxSessionsPerUser", MaxSessionsPerUser.Get(context)); } if (MaxMemoryPerSessionMB.Expression != null) { targetCommand.AddParameter("MaxMemoryPerSessionMB", MaxMemoryPerSessionMB.Get(context)); } if (MaxProcessesPerSession.Expression != null) { targetCommand.AddParameter("MaxProcessesPerSession", MaxProcessesPerSession.Get(context)); } if (MaxConcurrentUsers.Expression != null) { targetCommand.AddParameter("MaxConcurrentUsers", MaxConcurrentUsers.Get(context)); } if (IdleTimeoutSec.Expression != null) { targetCommand.AddParameter("IdleTimeoutSec", IdleTimeoutSec.Get(context)); } if (OutputBufferingMode.Expression != null) { targetCommand.AddParameter("OutputBufferingMode", OutputBufferingMode.Get(context)); } return(new ActivityImplementationContext() { PowerShellInstance = invoker }); }
// Module defining this command // Optional custom code for this activity /// <summary> /// Returns a configured instance of System.Management.Automation.PowerShell, pre-populated with the command to run. /// </summary> /// <param name="context">The NativeActivityContext for the currently running activity.</param> /// <returns>A populated instance of Sytem.Management.Automation.PowerShell</returns> /// <remarks>The infrastructure takes responsibility for closing and disposing the PowerShell instance returned.</remarks> protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context) { System.Management.Automation.PowerShell invoker = global::System.Management.Automation.PowerShell.Create(); System.Management.Automation.PowerShell targetCommand = invoker.AddCommand(PSCommandName); // Initialize the arguments if (Path.Expression != null) { targetCommand.AddParameter("Path", Path.Get(context)); } if (LiteralPath.Expression != null) { targetCommand.AddParameter("LiteralPath", LiteralPath.Get(context)); } if (Filter.Expression != null) { targetCommand.AddParameter("Filter", Filter.Get(context)); } if (Include.Expression != null) { targetCommand.AddParameter("Include", Include.Get(context)); } if (Exclude.Expression != null) { targetCommand.AddParameter("Exclude", Exclude.Get(context)); } if (PathType.Expression != null) { targetCommand.AddParameter("PathType", PathType.Get(context)); } if (IsValid.Expression != null) { targetCommand.AddParameter("IsValid", IsValid.Get(context)); } if (Credential.Expression != null) { targetCommand.AddParameter("Credential", Credential.Get(context)); } if (OlderThan.Expression != null) { targetCommand.AddParameter("OlderThan", OlderThan.Get(context)); } if (NewerThan.Expression != null) { targetCommand.AddParameter("NewerThan", NewerThan.Get(context)); } return(new ActivityImplementationContext() { PowerShellInstance = invoker }); }
/// <summary> /// Loads and retrieves information about a given module. /// </summary> /// <param name="module">The module to load, given as a PSModuleInfo.</param> /// <param name="error">Any error encountered, if any.</param> /// <returns>The name, version and data object for the module, or null if data collection did not succeed.</returns> public Tuple <string, Version, ModuleData> LoadAndGetModuleData(PSModuleInfo module, out Exception error) { try { PSModuleInfo importedModule = _pwsh.AddCommand(s_ipmoInfo) .AddParameter("ModuleInfo", module) .AddParameter("PassThru") .AddParameter("ErrorAction", "Stop") .InvokeAndClear <PSModuleInfo>() .FirstOrDefault(); if (importedModule == null) { error = null; return(null); } Tuple <string, Version, ModuleData> moduleData = GetSingleModuleData(importedModule); _pwsh.AddCommand(s_rmoInfo) .AddParameter("ModuleInfo", importedModule) .InvokeAndClear(); error = null; return(moduleData); } catch (RuntimeException e) { // A common problem is TypeData being hit with other modules, this overrides that if (e.ErrorRecord.FullyQualifiedErrorId.Equals("FormatXmlUpdateException,Microsoft.PowerShell.Commands.ImportModuleCommand") || e.ErrorRecord.FullyQualifiedErrorId.Equals("ErrorsUpdatingTypes")) { foreach (string typeDataName in GetTypeDataNamesFromErrorMessage(e.Message)) { _pwsh.AddCommand("Remove-TypeData") .AddParameter("TypeName", typeDataName) .InvokeAndClear(); } } // Attempt to load the module in a new runspace instead try { using (SMA.PowerShell fallbackPwsh = SMA.PowerShell.Create(RunspaceMode.NewRunspace)) { PSModuleInfo importedModule = fallbackPwsh.AddCommand(s_ipmoInfo) .AddParameter("Name", module.Path) .AddParameter("PassThru") .AddParameter("Force") .AddParameter("ErrorAction", "Stop") .InvokeAndClear <PSModuleInfo>() .FirstOrDefault(); error = null; return(GetSingleModuleData(importedModule)); } } catch (Exception fallbackException) { error = fallbackException; return(null); } } }
// Module defining this command // Optional custom code for this activity /// <summary> /// Returns a configured instance of System.Management.Automation.PowerShell, pre-populated with the command to run. /// </summary> /// <param name="context">The NativeActivityContext for the currently running activity.</param> /// <returns>A populated instance of Sytem.Management.Automation.PowerShell</returns> /// <remarks>The infrastructure takes responsibility for closing and disposing the PowerShell instance returned.</remarks> protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context) { System.Management.Automation.PowerShell invoker = global::System.Management.Automation.PowerShell.Create(); System.Management.Automation.PowerShell targetCommand = invoker.AddCommand(PSCommandName); // Initialize the arguments if (Method.Expression != null) { targetCommand.AddParameter("Method", Method.Get(context)); } if (UseBasicParsing.Expression != null) { targetCommand.AddParameter("UseBasicParsing", UseBasicParsing.Get(context)); } if (Uri.Expression != null) { targetCommand.AddParameter("Uri", Uri.Get(context)); } if (WebSession.Expression != null) { targetCommand.AddParameter("WebSession", WebSession.Get(context)); } if (SessionVariable.Expression != null) { targetCommand.AddParameter("SessionVariable", SessionVariable.Get(context)); } if (Credential.Expression != null) { targetCommand.AddParameter("Credential", Credential.Get(context)); } if (UseDefaultCredentials.Expression != null) { targetCommand.AddParameter("UseDefaultCredentials", UseDefaultCredentials.Get(context)); } if (CertificateThumbprint.Expression != null) { targetCommand.AddParameter("CertificateThumbprint", CertificateThumbprint.Get(context)); } if (Certificate.Expression != null) { targetCommand.AddParameter("Certificate", Certificate.Get(context)); } if (UserAgent.Expression != null) { targetCommand.AddParameter("UserAgent", UserAgent.Get(context)); } if (DisableKeepAlive.Expression != null) { targetCommand.AddParameter("DisableKeepAlive", DisableKeepAlive.Get(context)); } if (TimeoutSec.Expression != null) { targetCommand.AddParameter("TimeoutSec", TimeoutSec.Get(context)); } if (Headers.Expression != null) { targetCommand.AddParameter("Headers", Headers.Get(context)); } if (MaximumRedirection.Expression != null) { targetCommand.AddParameter("MaximumRedirection", MaximumRedirection.Get(context)); } if (Proxy.Expression != null) { targetCommand.AddParameter("Proxy", Proxy.Get(context)); } if (ProxyCredential.Expression != null) { targetCommand.AddParameter("ProxyCredential", ProxyCredential.Get(context)); } if (ProxyUseDefaultCredentials.Expression != null) { targetCommand.AddParameter("ProxyUseDefaultCredentials", ProxyUseDefaultCredentials.Get(context)); } if (Body.Expression != null) { targetCommand.AddParameter("Body", Body.Get(context)); } if (ContentType.Expression != null) { targetCommand.AddParameter("ContentType", ContentType.Get(context)); } if (TransferEncoding.Expression != null) { targetCommand.AddParameter("TransferEncoding", TransferEncoding.Get(context)); } if (InFile.Expression != null) { targetCommand.AddParameter("InFile", InFile.Get(context)); } if (OutFile.Expression != null) { targetCommand.AddParameter("OutFile", OutFile.Get(context)); } if (PassThru.Expression != null) { targetCommand.AddParameter("PassThru", PassThru.Get(context)); } return(new ActivityImplementationContext() { PowerShellInstance = invoker }); }
/// <summary> /// Get a module data object for the Microsoft.PowerShell.Core pseudo-module. /// The version is given as the PowerShell version. /// </summary> /// <returns>The name, version and data of the core pseudo-module.</returns> public Tuple <string, Version, ModuleData> GetCoreModuleData() { var moduleData = new ModuleData(); IEnumerable <CommandInfo> coreCommands = _pwsh.AddCommand(GcmInfo) .AddParameter("Module", CORE_MODULE_NAME) .InvokeAndClear <CommandInfo>(); var cmdletData = new JsonCaseInsensitiveStringDictionary <CmdletData>(); var functionData = new JsonCaseInsensitiveStringDictionary <FunctionData>(); foreach (CommandInfo command in coreCommands) { switch (command) { case CmdletInfo cmdlet: try { cmdletData.Add(cmdlet.Name, GetSingleCmdletData(cmdlet)); } catch (RuntimeException) { // If we can't load the cmdlet, we just move on } continue; case FunctionInfo function: try { functionData.Add(function.Name, GetSingleFunctionData(function)); } catch (RuntimeException) { // Some functions have problems loading, // which likely means PowerShell wouldn't be able to run them } continue; default: throw new CompatibilityAnalysisException($"Command {command.Name} in core module is of unsupported type {command.CommandType}"); } } moduleData.Cmdlets = cmdletData; moduleData.Functions = functionData; // Get default variables and core aliases out of a fresh runspace using (SMA.PowerShell freshPwsh = SMA.PowerShell.Create(RunspaceMode.NewRunspace)) { Collection <PSObject> varsAndAliases = freshPwsh.AddCommand("Get-ChildItem") .AddParameter("Path", "variable:,alias:") .InvokeAndClear(); var variables = new List <string>(); var aliases = new JsonCaseInsensitiveStringDictionary <string>(); foreach (PSObject returnedObject in varsAndAliases) { switch (returnedObject.BaseObject) { case PSVariable variable: variables.Add(variable.Name); continue; case AliasInfo alias: aliases.Add(alias.Name, GetSingleAliasData(alias)); continue; // Skip over other objects we get back, since there's no reason to throw } } moduleData.Variables = variables.ToArray(); moduleData.Aliases = aliases; } Version psVersion = _psVersion.PreReleaseLabel != null ? new Version(_psVersion.Major, _psVersion.Minor, _psVersion.Build) : (Version)_psVersion; return(new Tuple <string, Version, ModuleData>(CORE_MODULE_NAME, psVersion, moduleData)); }
/// <summary> /// Returns a configured instance of System.Management.Automation.PowerShell, pre-populated with the command to run. /// </summary> /// <param name="context">The NativeActivityContext for the currently running activity.</param> /// <returns>A populated instance of System.Management.Automation.PowerShell</returns> /// <remarks>The infrastructure takes responsibility for closing and disposing the PowerShell instance returned.</remarks> protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context) { System.Management.Automation.PowerShell invoker = global::System.Management.Automation.PowerShell.Create(); System.Management.Automation.PowerShell targetCommand = invoker.AddCommand(PSCommandName); // Get the host default values we should use if no explicit parameter was provided. var hostExtension = context.GetExtension <HostParameterDefaults>(); Dictionary <string, object> parameterDefaults = new Dictionary <string, object>(StringComparer.OrdinalIgnoreCase); if (hostExtension != null) { Dictionary <string, object> incomingArguments = hostExtension.Parameters; foreach (KeyValuePair <string, object> parameterDefault in incomingArguments) { parameterDefaults[parameterDefault.Key] = parameterDefault.Value; } } if (DcomAuthentication.Expression != null) { targetCommand.AddParameter("DcomAuthentication", DcomAuthentication.Get(context)); } if (Impersonation.Expression != null) { targetCommand.AddParameter("Impersonation", Impersonation.Get(context)); } // See if the DCOM protocol is to be used bool usingDcom = false; if (Protocol.Expression != null) { string protocol = Protocol.Get(context); targetCommand.AddParameter("Protocol", protocol); if (string.Equals(protocol, "DCOM", StringComparison.OrdinalIgnoreCase)) { usingDcom = true; } } // Get the WSMan authentication mechanism to use. If no expression was specified, // and DCOM is not being used, get the default from the host. if (WsmanAuthentication.Expression != null) { targetCommand.AddParameter("WsmanAuthentication", WsmanAuthentication.Get(context)); } else { if (!usingDcom) { if (parameterDefaults.ContainsKey("PSAuthentication")) { string authString = parameterDefaults["PSAuthentication"].ToString(); // Note: the underlying cmdlet does support NegotiateWithImplicitCredential so it is expected // that passing this in as-is will result in an (appropriate) error being emitted in that case. targetCommand.AddParameter("WsmanAuthentication", authString); } } } // Map PSComputerName to the underlying cmdlet name only if the computername is not empty string[] computerName = GetPSComputerName(context); if ((computerName != null) && (computerName.Length != 0)) { targetCommand.AddParameter("ComputerName", computerName); } // Map PSCredential to credential. If no expression was provided, then use the default. if (PSCredential.Expression != null) { targetCommand.AddParameter("Credential", PSCredential.Get(context)); } else { if (parameterDefaults.ContainsKey("PSCredential")) { targetCommand.AddParameter("Credential", parameterDefaults["PSCredential"]); } } if (Force.Expression != null) { targetCommand.AddParameter("Force", Force.Get(context)); } if (ThrottleLimit.Expression != null) { targetCommand.AddParameter("ThrottleLimit", ThrottleLimit.Get(context)); } // Ignore the -Wait parameter in the self-restart case. if (!IsSelfRestart(context)) { if (Wait.Expression != null) { targetCommand.AddParameter("Wait", Wait.Get(context)); } if (For.Expression != null) { targetCommand.AddParameter("For", For.Get(context)); } if (Delay.Expression != null) { targetCommand.AddParameter("Delay", Delay.Get(context)); } } if (Timeout.Expression != null) { targetCommand.AddParameter("Timeout", Timeout.Get(context)); } return(new ActivityImplementationContext() { PowerShellInstance = invoker }); }
// Module defining this command // Optional custom code for this activity /// <summary> /// Returns a configured instance of System.Management.Automation.PowerShell, pre-populated with the command to run. /// </summary> /// <param name="context">The NativeActivityContext for the currently running activity.</param> /// <returns>A populated instance of System.Management.Automation.PowerShell</returns> /// <remarks>The infrastructure takes responsibility for closing and disposing the PowerShell instance returned.</remarks> protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context) { System.Management.Automation.PowerShell invoker = global::System.Management.Automation.PowerShell.Create(); System.Management.Automation.PowerShell targetCommand = invoker.AddCommand(PSCommandName); // Initialize the arguments if (ProcessorArchitecture.Expression != null) { targetCommand.AddParameter("ProcessorArchitecture", ProcessorArchitecture.Get(context)); } if (SessionType.Expression != null) { targetCommand.AddParameter("SessionType", SessionType.Get(context)); } if (Name.Expression != null) { targetCommand.AddParameter("Name", Name.Get(context)); } if (AssemblyName.Expression != null) { targetCommand.AddParameter("AssemblyName", AssemblyName.Get(context)); } if (ApplicationBase.Expression != null) { targetCommand.AddParameter("ApplicationBase", ApplicationBase.Get(context)); } if (ConfigurationTypeName.Expression != null) { targetCommand.AddParameter("ConfigurationTypeName", ConfigurationTypeName.Get(context)); } if (RunAsCredential.Expression != null) { targetCommand.AddParameter("RunAsCredential", RunAsCredential.Get(context)); } if (ThreadApartmentState.Expression != null) { targetCommand.AddParameter("ThreadApartmentState", ThreadApartmentState.Get(context)); } if (ThreadOptions.Expression != null) { targetCommand.AddParameter("ThreadOptions", ThreadOptions.Get(context)); } if (AccessMode.Expression != null) { targetCommand.AddParameter("AccessMode", AccessMode.Get(context)); } if (UseSharedProcess.Expression != null) { targetCommand.AddParameter("UseSharedProcess", UseSharedProcess.Get(context)); } if (StartupScript.Expression != null) { targetCommand.AddParameter("StartupScript", StartupScript.Get(context)); } if (MaximumReceivedDataSizePerCommandMB.Expression != null) { targetCommand.AddParameter("MaximumReceivedDataSizePerCommandMB", MaximumReceivedDataSizePerCommandMB.Get(context)); } if (MaximumReceivedObjectSizeMB.Expression != null) { targetCommand.AddParameter("MaximumReceivedObjectSizeMB", MaximumReceivedObjectSizeMB.Get(context)); } if (SecurityDescriptorSddl.Expression != null) { targetCommand.AddParameter("SecurityDescriptorSddl", SecurityDescriptorSddl.Get(context)); } if (ShowSecurityDescriptorUI.Expression != null) { targetCommand.AddParameter("ShowSecurityDescriptorUI", ShowSecurityDescriptorUI.Get(context)); } if (Force.Expression != null) { targetCommand.AddParameter("Force", Force.Get(context)); } if (NoServiceRestart.Expression != null) { targetCommand.AddParameter("NoServiceRestart", NoServiceRestart.Get(context)); } if (PSVersion.Expression != null) { targetCommand.AddParameter("PSVersion", PSVersion.Get(context)); } if (SessionTypeOption.Expression != null) { targetCommand.AddParameter("SessionTypeOption", SessionTypeOption.Get(context)); } if (TransportOption.Expression != null) { targetCommand.AddParameter("TransportOption", TransportOption.Get(context)); } if (ModulesToImport.Expression != null) { targetCommand.AddParameter("ModulesToImport", ModulesToImport.Get(context)); } if (Path.Expression != null) { targetCommand.AddParameter("Path", Path.Get(context)); } return(new ActivityImplementationContext() { PowerShellInstance = invoker }); }
/// <summary> /// A helper class that builds and executes a pipeline that writes to the /// default output path. Any exceptions that are thrown are just passed to /// the caller. Since all output goes to the default outter, this method() /// won't return anything. /// </summary> /// <param name="cmd">The script to run</param> /// <param name="input">Any input arguments to pass to the script. If null /// then nothing is passed in.</param> void executeHelper(string cmd, object input) { // Just ignore empty command lines... if (String.IsNullOrEmpty(cmd)) return; // Create the pipeline object and make it available // to the ctrl-C handle through the currentPowerShell instance // variable lock (instanceLock) { currentPowerShell = PowerShell.Create(); } currentPowerShell.Runspace = myRunSpace; // Create a pipeline for this execution - place the result in the currentPowerShell // instance variable so it is available to be stopped. try { currentPowerShell.AddScript(cmd); // Now add the default outputter to the end of the pipe and indicate // that it should handle both output and errors from the previous // commands. This will result in the output being written using the PSHost // and PSHostUserInterface classes instead of returning objects to the hosting // application. currentPowerShell.AddCommand("out-default"); currentPowerShell.Commands.Commands[0].MergeMyResults(PipelineResultTypes.Error, PipelineResultTypes.Output); // If there was any input specified, pass it in, otherwise just // execute the pipeline... if (input != null) { currentPowerShell.Invoke(new object[] { input }); } else { currentPowerShell.Invoke(); } } finally { // Dispose of the pipeline line and set it to null, locked because currentPowerShell // may be accessed by the ctrl-C handler... lock (instanceLock) { currentPowerShell.Dispose(); currentPowerShell = null; } } }
// Module defining this command // Optional custom code for this activity /// <summary> /// Returns a configured instance of System.Management.Automation.PowerShell, pre-populated with the command to run. /// </summary> /// <param name="context">The NativeActivityContext for the currently running activity.</param> /// <returns>A populated instance of Sytem.Management.Automation.PowerShell</returns> /// <remarks>The infrastructure takes responsibility for closing and disposing the PowerShell instance returned.</remarks> protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context) { System.Management.Automation.PowerShell invoker = global::System.Management.Automation.PowerShell.Create(); System.Management.Automation.PowerShell targetCommand = invoker.AddCommand(PSCommandName); // Initialize the arguments if (InputObject.Expression != null) { targetCommand.AddParameter("InputObject", InputObject.Get(context)); } if (FilterScript.Expression != null) { targetCommand.AddParameter("FilterScript", FilterScript.Get(context)); } if (Property.Expression != null) { targetCommand.AddParameter("Property", Property.Get(context)); } if (Value.Expression != null) { targetCommand.AddParameter("Value", Value.Get(context)); } if (EQ.Expression != null) { targetCommand.AddParameter("EQ", EQ.Get(context)); } if (CEQ.Expression != null) { targetCommand.AddParameter("CEQ", CEQ.Get(context)); } if (NE.Expression != null) { targetCommand.AddParameter("NE", NE.Get(context)); } if (CNE.Expression != null) { targetCommand.AddParameter("CNE", CNE.Get(context)); } if (GT.Expression != null) { targetCommand.AddParameter("GT", GT.Get(context)); } if (CGT.Expression != null) { targetCommand.AddParameter("CGT", CGT.Get(context)); } if (LT.Expression != null) { targetCommand.AddParameter("LT", LT.Get(context)); } if (CLT.Expression != null) { targetCommand.AddParameter("CLT", CLT.Get(context)); } if (GE.Expression != null) { targetCommand.AddParameter("GE", GE.Get(context)); } if (CGE.Expression != null) { targetCommand.AddParameter("CGE", CGE.Get(context)); } if (LE.Expression != null) { targetCommand.AddParameter("LE", LE.Get(context)); } if (CLE.Expression != null) { targetCommand.AddParameter("CLE", CLE.Get(context)); } if (Like.Expression != null) { targetCommand.AddParameter("Like", Like.Get(context)); } if (CLike.Expression != null) { targetCommand.AddParameter("CLike", CLike.Get(context)); } if (NotLike.Expression != null) { targetCommand.AddParameter("NotLike", NotLike.Get(context)); } if (CNotLike.Expression != null) { targetCommand.AddParameter("CNotLike", CNotLike.Get(context)); } if (Match.Expression != null) { targetCommand.AddParameter("Match", Match.Get(context)); } if (CMatch.Expression != null) { targetCommand.AddParameter("CMatch", CMatch.Get(context)); } if (NotMatch.Expression != null) { targetCommand.AddParameter("NotMatch", NotMatch.Get(context)); } if (CNotMatch.Expression != null) { targetCommand.AddParameter("CNotMatch", CNotMatch.Get(context)); } if (Contains.Expression != null) { targetCommand.AddParameter("Contains", Contains.Get(context)); } if (CContains.Expression != null) { targetCommand.AddParameter("CContains", CContains.Get(context)); } if (NotContains.Expression != null) { targetCommand.AddParameter("NotContains", NotContains.Get(context)); } if (CNotContains.Expression != null) { targetCommand.AddParameter("CNotContains", CNotContains.Get(context)); } if (In.Expression != null) { targetCommand.AddParameter("In", In.Get(context)); } if (CIn.Expression != null) { targetCommand.AddParameter("CIn", CIn.Get(context)); } if (NotIn.Expression != null) { targetCommand.AddParameter("NotIn", NotIn.Get(context)); } if (CNotIn.Expression != null) { targetCommand.AddParameter("CNotIn", CNotIn.Get(context)); } if (Is.Expression != null) { targetCommand.AddParameter("Is", Is.Get(context)); } if (IsNot.Expression != null) { targetCommand.AddParameter("IsNot", IsNot.Get(context)); } return(new ActivityImplementationContext() { PowerShellInstance = invoker }); }
// Module defining this command // Optional custom code for this activity /// <summary> /// Returns a configured instance of System.Management.Automation.PowerShell, pre-populated with the command to run. /// </summary> /// <param name="context">The NativeActivityContext for the currently running activity.</param> /// <returns>A populated instance of System.Management.Automation.PowerShell</returns> /// <remarks>The infrastructure takes responsibility for closing and disposing the PowerShell instance returned.</remarks> protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context) { System.Management.Automation.PowerShell invoker = global::System.Management.Automation.PowerShell.Create(); System.Management.Automation.PowerShell targetCommand = invoker.AddCommand(PSCommandName); // Initialize the arguments if (InputObject.Expression != null) { targetCommand.AddParameter("InputObject", InputObject.Get(context)); } if (MemberType.Expression != null) { targetCommand.AddParameter("MemberType", MemberType.Get(context)); } if (Name.Expression != null) { targetCommand.AddParameter("Name", Name.Get(context)); } if (Value.Expression != null) { targetCommand.AddParameter("Value", Value.Get(context)); } if (SecondValue.Expression != null) { targetCommand.AddParameter("SecondValue", SecondValue.Get(context)); } if (TypeName.Expression != null) { targetCommand.AddParameter("TypeName", TypeName.Get(context)); } if (Force.Expression != null) { targetCommand.AddParameter("Force", Force.Get(context)); } if (PassThru.Expression != null) { targetCommand.AddParameter("PassThru", PassThru.Get(context)); } if (NotePropertyName.Expression != null) { targetCommand.AddParameter("NotePropertyName", NotePropertyName.Get(context)); } if (NotePropertyValue.Expression != null) { targetCommand.AddParameter("NotePropertyValue", NotePropertyValue.Get(context)); } if (NotePropertyMembers.Expression != null) { targetCommand.AddParameter("NotePropertyMembers", NotePropertyMembers.Get(context)); } return(new ActivityImplementationContext() { PowerShellInstance = invoker }); }
// Module defining this command // Optional custom code for this activity /// <summary> /// Returns a configured instance of System.Management.Automation.PowerShell, pre-populated with the command to run. /// </summary> /// <param name="context">The NativeActivityContext for the currently running activity.</param> /// <returns>A populated instance of System.Management.Automation.PowerShell</returns> /// <remarks>The infrastructure takes responsibility for closing and disposing the PowerShell instance returned.</remarks> protected override ActivityImplementationContext GetPowerShell(NativeActivityContext context) { System.Management.Automation.PowerShell invoker = global::System.Management.Automation.PowerShell.Create(); System.Management.Automation.PowerShell targetCommand = invoker.AddCommand(PSCommandName); // Initialize the arguments if (ApplicationName.Expression != null) { targetCommand.AddParameter("ApplicationName", ApplicationName.Get(context)); } if (BasePropertiesOnly.Expression != null) { targetCommand.AddParameter("BasePropertiesOnly", BasePropertiesOnly.Get(context)); } if ((ComputerName.Expression != null) && (PSRemotingBehavior.Get(context) != RemotingBehavior.Custom)) { targetCommand.AddParameter("ComputerName", ComputerName.Get(context)); } if (ConnectionURI.Expression != null) { targetCommand.AddParameter("ConnectionURI", ConnectionURI.Get(context)); } if (Dialect.Expression != null) { targetCommand.AddParameter("Dialect", Dialect.Get(context)); } if (Enumerate.Expression != null) { targetCommand.AddParameter("Enumerate", Enumerate.Get(context)); } if (Filter.Expression != null) { targetCommand.AddParameter("Filter", Filter.Get(context)); } if (Fragment.Expression != null) { targetCommand.AddParameter("Fragment", Fragment.Get(context)); } if (OptionSet.Expression != null) { targetCommand.AddParameter("OptionSet", OptionSet.Get(context)); } if (Port.Expression != null) { targetCommand.AddParameter("Port", Port.Get(context)); } if (Associations.Expression != null) { targetCommand.AddParameter("Associations", Associations.Get(context)); } if (ResourceURI.Expression != null) { targetCommand.AddParameter("ResourceURI", ResourceURI.Get(context)); } if (ReturnType.Expression != null) { targetCommand.AddParameter("ReturnType", ReturnType.Get(context)); } if (SelectorSet.Expression != null) { targetCommand.AddParameter("SelectorSet", SelectorSet.Get(context)); } if (SessionOption.Expression != null) { targetCommand.AddParameter("SessionOption", SessionOption.Get(context)); } if (Shallow.Expression != null) { targetCommand.AddParameter("Shallow", Shallow.Get(context)); } if (UseSSL.Expression != null) { targetCommand.AddParameter("UseSSL", UseSSL.Get(context)); } if (Credential.Expression != null) { targetCommand.AddParameter("Credential", Credential.Get(context)); } if (Authentication.Expression != null) { targetCommand.AddParameter("Authentication", Authentication.Get(context)); } if (CertificateThumbprint.Expression != null) { targetCommand.AddParameter("CertificateThumbprint", CertificateThumbprint.Get(context)); } if (GetIsComputerNameSpecified(context) && (PSRemotingBehavior.Get(context) == RemotingBehavior.Custom)) { targetCommand.AddParameter("ComputerName", PSComputerName.Get(context)); } return(new ActivityImplementationContext() { PowerShellInstance = invoker }); }
/// <summary> /// Execution of PowerShell value activity. /// PowerShell expression will be evaluated using PowerShell runspace and the value of Type T will be returned. /// </summary> /// <param name="context"></param> protected override void Execute(NativeActivityContext context) { Token[] tokens; ParseError[] errors; ScriptBlockAst exprAst = Parser.ParseInput(Expression, out tokens, out errors); bool hasErrorActionPreference = false; bool hasWarningPreference = false; bool hasInformationPreference = false; // Custom activity participant tracker for updating debugger with current variables and sequence stop points. // Regex looks for debugger sequence points like: Expression="'3:5:WFFunc1'". // We specifically disallow TimeSpan values that look like sequence points: Expression="'00:00:01'". bool isDebugSequencePoint = (!string.IsNullOrEmpty(Expression) && (System.Text.RegularExpressions.Regex.IsMatch(Expression, @"^'\d+:\d+:\S+'$")) && (typeof(T) != typeof(System.TimeSpan))); var dataProperties = context.DataContext.GetProperties(); if (isDebugSequencePoint || (dataProperties.Count > 0)) { System.Activities.Tracking.CustomTrackingRecord customRecord = new System.Activities.Tracking.CustomTrackingRecord("PSWorkflowCustomUpdateDebugVariablesTrackingRecord"); foreach (System.ComponentModel.PropertyDescriptor property in dataProperties) { if (String.Equals(property.Name, "ParameterDefaults", StringComparison.OrdinalIgnoreCase)) { continue; } Object value = property.GetValue(context.DataContext); if (value != null) { object tempValue = value; PSDataCollection <PSObject> collectionObject = value as PSDataCollection <PSObject>; if (collectionObject != null && collectionObject.Count == 1) { tempValue = collectionObject[0]; } customRecord.Data.Add(property.Name, tempValue); } } if (isDebugSequencePoint) { customRecord.Data.Add("DebugSequencePoint", Expression); } context.Track(customRecord); } if (tokens != null) { foreach (Token token in tokens) { VariableToken variable = token as VariableToken; if (variable != null) { if (variable.Name.Equals("ErrorActionPreference", StringComparison.OrdinalIgnoreCase)) { hasErrorActionPreference = true; } else if (variable.Name.Equals("WarningPreference", StringComparison.OrdinalIgnoreCase)) { hasWarningPreference = true; } else if (variable.Name.Equals("InformationPreference", StringComparison.OrdinalIgnoreCase)) { hasInformationPreference = true; } } } } if (string.IsNullOrEmpty(Expression)) { throw new ArgumentException(ActivityResources.NullArgumentExpression); } if (_ci == null) { lock (syncroot) { // Invoke using the CommandInfo for Invoke-Command directly, rather than going through // command discovery (which is very slow). if (_ci == null) { _ci = new CmdletInfo("Invoke-Command", typeof(Microsoft.PowerShell.Commands.InvokeCommandCommand)); } } } Collection <PSObject> returnedvalue; Runspace runspace = null; bool borrowedRunspace = false; PSWorkflowHost workflowHost = null; if (typeof(ScriptBlock).IsAssignableFrom(typeof(T))) { Result.Set(context, ScriptBlock.Create(Expression)); return; } else if (typeof(ScriptBlock[]).IsAssignableFrom(typeof(T))) { Result.Set(context, new ScriptBlock[] { ScriptBlock.Create(Expression) }); return; } PropertyDescriptorCollection col = context.DataContext.GetProperties(); HostParameterDefaults hostValues = context.GetExtension <HostParameterDefaults>(); // Borrow a runspace from the host if we're not trying to create a ScriptBlock. // If we are trying to create one, we need to keep it around so that it can be // invoked multiple times. if (hostValues != null) { workflowHost = hostValues.Runtime; try { runspace = workflowHost.UnboundedLocalRunspaceProvider.GetRunspace(null, 0, 0); borrowedRunspace = true; } catch (Exception) { // it is fine to catch generic exception here // if the local runspace provider does not give us // a runspace we will create one locally (fallback) } } if (runspace == null) { // Not running with the PowerShell workflow host so directly create the runspace... runspace = RunspaceFactory.CreateRunspace(InitialSessionState.CreateDefault2()); runspace.Open(); } using (System.Management.Automation.PowerShell ps = System.Management.Automation.PowerShell.Create()) { try { ps.Runspace = runspace; // Subscribe to DataAdding on the error stream so that we can add position tracking information if (hostValues != null) { HostSettingCommandMetadata sourceCommandMetadata = hostValues.HostCommandMetadata; CommandMetadataTable.TryAdd(ps.InstanceId, sourceCommandMetadata); ps.Streams.Error.DataAdding += HandleErrorDataAdding; } // First, set the variables from the host defaults if ((hostValues != null) && (hostValues.Parameters != null)) { if (hostValues.Parameters.ContainsKey("PSCurrentDirectory")) { string path = hostValues.Parameters["PSCurrentDirectory"] as string; if (path != null) { ps.Runspace.SessionStateProxy.Path.SetLocation(path); } } foreach (string hostDefault in hostValues.Parameters.Keys) { string mappedHostDefault = hostDefault; if (hostDefault.Equals("ErrorAction", StringComparison.OrdinalIgnoreCase)) { if (hasErrorActionPreference) { mappedHostDefault = "ErrorActionPreference"; } else { continue; } } else if (hostDefault.Equals("WarningAction", StringComparison.OrdinalIgnoreCase)) { if (hasWarningPreference) { mappedHostDefault = "WarningPreference"; } else { continue; } } else if (hostDefault.Equals("InformationAction", StringComparison.OrdinalIgnoreCase)) { if (hasInformationPreference) { mappedHostDefault = "InformationPreference"; } else { continue; } } object propertyValue = hostValues.Parameters[hostDefault]; if (propertyValue != null) { ps.Runspace.SessionStateProxy.PSVariable.Set(mappedHostDefault, propertyValue); } } } // Then, set the variables from the workflow foreach (PropertyDescriptor p in col) { string name = p.Name; object value = p.GetValue(context.DataContext); if (value != null) { object tempValue = value; PSDataCollection <PSObject> collectionObject = value as PSDataCollection <PSObject>; if (collectionObject != null && collectionObject.Count == 1) { tempValue = collectionObject[0]; } ps.Runspace.SessionStateProxy.PSVariable.Set(name, tempValue); } } ps.AddCommand(_ci).AddParameter("NoNewScope").AddParameter("ScriptBlock", ExpressionScriptBlock); // If this needs to consume input, take it from the host stream. PSDataCollection <PSObject> inputStream = null; if (UseDefaultInput) { // Retrieve our host overrides hostValues = context.GetExtension <HostParameterDefaults>(); if (hostValues != null) { Dictionary <string, object> incomingArguments = hostValues.Parameters; if (incomingArguments.ContainsKey("Input")) { inputStream = incomingArguments["Input"] as PSDataCollection <PSObject>; } } } // Now invoke the pipeline try { if (inputStream != null) { returnedvalue = ps.Invoke(inputStream); inputStream.Clear(); } else { returnedvalue = ps.Invoke(); } } catch (CmdletInvocationException cie) { if (cie.ErrorRecord != null && cie.ErrorRecord.Exception != null) { throw cie.InnerException; } else { throw; } } } finally { if (hostValues != null) { ps.Streams.Error.DataAdding -= HandleErrorDataAdding; HostSettingCommandMetadata removedValue; CommandMetadataTable.TryRemove(ps.InstanceId, out removedValue); } if (borrowedRunspace) { workflowHost.UnboundedLocalRunspaceProvider.ReleaseRunspace(runspace); } else { // This will be disposed when the command is done with it. runspace.Dispose(); runspace = null; } } if (ps.Streams.Error != null && ps.Streams.Error.Count > 0) { PSDataCollection <ErrorRecord> errorStream = null; // Retrieve our host overrides hostValues = context.GetExtension <HostParameterDefaults>(); if (hostValues != null) { Dictionary <string, object> incomingArguments = hostValues.Parameters; if (incomingArguments.ContainsKey("PSError")) { errorStream = incomingArguments["PSError"] as PSDataCollection <ErrorRecord>; } } if (errorStream != null && errorStream.IsOpen) { foreach (ErrorRecord record in ps.Streams.Error) { errorStream.Add(record); } } } T valueToReturn = default(T); if (returnedvalue != null && returnedvalue.Count > 0) { try { if (returnedvalue.Count == 1) { if (returnedvalue[0] != null) { Object result = returnedvalue[0]; Object baseObject = ((PSObject)result).BaseObject; if (!(baseObject is PSCustomObject)) { result = baseObject; } // Try regular PowerShell conversion valueToReturn = LanguagePrimitives.ConvertTo <T>(result); } } else { valueToReturn = LanguagePrimitives.ConvertTo <T>(returnedvalue); } } catch (PSInvalidCastException) { // Handle the special case of emitting a PSDataCollection - use its array constructor. // This special case is why we aren't using PowerShell.Invoke<T> if (typeof(T) == typeof(PSDataCollection <PSObject>)) { Object tempValueToReturn = new PSDataCollection <PSObject>( new List <PSObject> { LanguagePrimitives.ConvertTo <PSObject>(returnedvalue[0]) }); valueToReturn = (T)tempValueToReturn; } else { throw; } } Result.Set(context, valueToReturn); } } }